#![cfg_attr(feature = "nightly", feature(allocator_api))]
#![cfg_attr(feature = "nightly", feature(extern_types))]
#![cfg_attr(feature = "nightly", feature(hasher_prefixfree_extras))]
#![cfg_attr(feature = "nightly", feature(impl_trait_in_assoc_type))]
#![cfg_attr(feature = "nightly", feature(slice_range))]
#![warn(missing_docs)]
#![warn(unreachable_pub)]
#![warn(unused_results)]
#[cfg(feature = "nightly")]
pub mod aligned_alloc;
#[cfg(feature = "nightly")]
use std::alloc::Global;
use std::any;
use std::collections::hash_map::DefaultHasher;
use std::hash::{Hash, Hasher};
use std::ops::RangeFull;
#[cfg(feature = "serde")]
use serde_test::{assert_tokens, Token};
#[cfg(feature = "nightly")]
use aligned_alloc::AlignedAlloc;
use mdarray::expr::{Expr, ExprMut};
use mdarray::mapping::{DenseMapping, FlatMapping, GeneralMapping, Mapping, StridedMapping};
use mdarray::{array, expr, grid, step, Array, DGrid, Grid, StepRange};
use mdarray::{Apply, Expression, IntoCloned, IntoExpression};
use mdarray::{Const, Dense, Dyn, Flat, General, Layout, Rank, Shape, Strided};
macro_rules! to_slice {
($span:expr) => {
$span.to_grid()[..]
};
}
fn check_mapping<S: Shape, L: Layout, M: Mapping>(_: M) {
assert_eq!(any::type_name::<L::Mapping<S>>(), any::type_name::<M>());
}
fn check_view<L: Layout>() {
let a = DGrid::<i32, 3>::from([[[0]]]);
let a = a.remap::<L>();
check_mapping::<Rank<0>, Dense, _>(a.view(0, 0, 0).mapping());
check_mapping::<Rank<1>, L::Uniform, _>(a.view(.., 0, 0).mapping());
check_mapping::<Rank<1>, L::Uniform, _>(a.view(1.., 0, 0).mapping());
check_mapping::<Rank<1>, Flat, _>(a.view(sr(), 0, 0).mapping());
check_mapping::<Rank<1>, Flat, _>(a.view(0, .., 0).mapping());
check_mapping::<Rank<2>, L, _>(a.view(.., .., 0).mapping());
check_mapping::<Rank<2>, L::NonUniform, _>(a.view(1.., .., 0).mapping());
check_mapping::<Rank<2>, Strided, _>(a.view(sr(), .., 0).mapping());
check_mapping::<Rank<1>, Flat, _>(a.view(0, 1.., 0).mapping());
check_mapping::<Rank<2>, L, _>(a.view(.., 1.., 0).mapping());
check_mapping::<Rank<2>, L::NonUniform, _>(a.view(1.., 1.., 0).mapping());
check_mapping::<Rank<2>, Strided, _>(a.view(sr(), 1.., 0).mapping());
check_mapping::<Rank<1>, Flat, _>(a.view(0, sr(), 0).mapping());
check_mapping::<Rank<2>, L::NonUniform, _>(a.view(.., sr(), 0).mapping());
check_mapping::<Rank<2>, L::NonUniform, _>(a.view(1.., sr(), 0).mapping());
check_mapping::<Rank<2>, Strided, _>(a.view(sr(), sr(), 0).mapping());
check_mapping::<Rank<1>, Flat, _>(a.view(0, 0, ..).mapping());
check_mapping::<Rank<2>, L::NonUniform, _>(a.view(.., 0, ..).mapping());
check_mapping::<Rank<2>, L::NonUniform, _>(a.view(1.., 0, ..).mapping());
check_mapping::<Rank<2>, Strided, _>(a.view(sr(), 0, ..).mapping());
check_mapping::<Rank<2>, L::NonUnitStrided, _>(a.view(0, .., ..).mapping());
check_mapping::<Rank<3>, L, _>(a.view(.., .., ..).mapping());
check_mapping::<Rank<3>, L::NonUniform, _>(a.view(1.., .., ..).mapping());
check_mapping::<Rank<3>, Strided, _>(a.view(sr(), .., ..).mapping());
check_mapping::<Rank<2>, Strided, _>(a.view(0, 1.., ..).mapping());
check_mapping::<Rank<3>, L::NonUniform, _>(a.view(.., 1.., ..).mapping());
check_mapping::<Rank<3>, L::NonUniform, _>(a.view(1.., 1.., ..).mapping());
check_mapping::<Rank<3>, Strided, _>(a.view(sr(), 1.., ..).mapping());
check_mapping::<Rank<2>, Strided, _>(a.view(0, sr(), ..).mapping());
check_mapping::<Rank<3>, L::NonUniform, _>(a.view(.., sr(), ..).mapping());
check_mapping::<Rank<3>, L::NonUniform, _>(a.view(1.., sr(), ..).mapping());
check_mapping::<Rank<3>, Strided, _>(a.view(sr(), sr(), ..).mapping());
check_mapping::<Rank<1>, Flat, _>(a.view(0, 0, 1..).mapping());
check_mapping::<Rank<2>, L::NonUniform, _>(a.view(.., 0, 1..).mapping());
check_mapping::<Rank<2>, L::NonUniform, _>(a.view(1.., 0, 1..).mapping());
check_mapping::<Rank<2>, Strided, _>(a.view(sr(), 0, 1..).mapping());
check_mapping::<Rank<2>, L::NonUnitStrided, _>(a.view(0, .., 1..).mapping());
check_mapping::<Rank<3>, L, _>(a.view(.., .., 1..).mapping());
check_mapping::<Rank<3>, L::NonUniform, _>(a.view(1.., .., 1..).mapping());
check_mapping::<Rank<3>, Strided, _>(a.view(sr(), .., 1..).mapping());
check_mapping::<Rank<2>, Strided, _>(a.view(0, 1.., 1..).mapping());
check_mapping::<Rank<3>, L::NonUniform, _>(a.view(.., 1.., 1..).mapping());
check_mapping::<Rank<3>, L::NonUniform, _>(a.view(1.., 1.., 1..).mapping());
check_mapping::<Rank<3>, Strided, _>(a.view(sr(), 1.., 1..).mapping());
check_mapping::<Rank<2>, Strided, _>(a.view(0, sr(), 1..).mapping());
check_mapping::<Rank<3>, L::NonUniform, _>(a.view(.., sr(), 1..).mapping());
check_mapping::<Rank<3>, L::NonUniform, _>(a.view(1.., sr(), 1..).mapping());
check_mapping::<Rank<3>, Strided, _>(a.view(sr(), sr(), 1..).mapping());
check_mapping::<Rank<1>, Flat, _>(a.view(0, 0, sr()).mapping());
check_mapping::<Rank<2>, L::NonUniform, _>(a.view(.., 0, sr()).mapping());
check_mapping::<Rank<2>, L::NonUniform, _>(a.view(1.., 0, sr()).mapping());
check_mapping::<Rank<2>, Strided, _>(a.view(sr(), 0, sr()).mapping());
check_mapping::<Rank<2>, Strided, _>(a.view(0, .., sr()).mapping());
check_mapping::<Rank<3>, L::NonUniform, _>(a.view(.., .., sr()).mapping());
check_mapping::<Rank<3>, L::NonUniform, _>(a.view(1.., .., sr()).mapping());
check_mapping::<Rank<3>, Strided, _>(a.view(sr(), .., sr()).mapping());
check_mapping::<Rank<2>, Strided, _>(a.view(0, 1.., sr()).mapping());
check_mapping::<Rank<3>, L::NonUniform, _>(a.view(.., 1.., sr()).mapping());
check_mapping::<Rank<3>, L::NonUniform, _>(a.view(1.., 1.., sr()).mapping());
check_mapping::<Rank<3>, Strided, _>(a.view(sr(), 1.., sr()).mapping());
check_mapping::<Rank<2>, Strided, _>(a.view(0, sr(), sr()).mapping());
check_mapping::<Rank<3>, L::NonUniform, _>(a.view(.., sr(), sr()).mapping());
check_mapping::<Rank<3>, L::NonUniform, _>(a.view(1.., sr(), sr()).mapping());
check_mapping::<Rank<3>, Strided, _>(a.view(sr(), sr(), sr()).mapping());
}
fn sr() -> StepRange<RangeFull, isize> {
step(.., 2)
}
#[test]
fn test_base() {
let mut a = DGrid::<usize, 3>::default();
#[cfg(not(feature = "nightly"))]
let mut b = DGrid::<usize, 3>::with_capacity(60);
#[cfg(feature = "nightly")]
let mut b = DGrid::<usize, 3>::with_capacity_in(60, a.allocator().clone());
a.resize([3, 4, 5], 0);
b.resize([5, 4, 3], 0);
assert_eq!(a.dim(1), 4);
assert_eq!(a.dims(), [3, 4, 5]);
assert_eq!(a.len(), 60);
assert_eq!(a.rank(), 3);
assert_eq!(a.stride(2), 12);
assert_eq!(a.strides(), [1, 3, 12]);
for i in 0..3 {
for j in 0..4 {
for k in 0..5 {
a[[i, j, k]] = 1000 + 100 * i + 10 * j + k;
b[[k, j, i]] = a[12 * k + 3 * j + i];
}
}
}
unsafe {
assert_eq!(*a.get_unchecked([2, 3, 4]), 1234);
*b.get_unchecked_mut([4, 3, 2]) = 1234;
}
assert_eq!(to_slice!(a.view(.., 2, 3)), [1023, 1123, 1223]);
assert_eq!(to_slice!(a.view(1, 1.., 3)), [1113, 1123, 1133]);
assert_eq!(to_slice!(a.view(1, 2, 2..)), [1122, 1123, 1124]);
assert_eq!(to_slice!(a.view(1.., ..2, 4)), [1104, 1204, 1114, 1214]);
assert_eq!(to_slice!(b.view(4, ..2, 1..)), [1104, 1114, 1204, 1214]);
assert_eq!(format!("{:?}", a.view(2, 1..3, ..2)), "[[1210, 1220], [1211, 1221]]");
assert_eq!(format!("{:?}", b.view(..2, 1..3, 2)), "[[1210, 1211], [1220, 1221]]");
assert_eq!(a.view(2, 1, ..), Expr::from([1210, 1211, 1212, 1213, 1214].as_slice()));
assert_eq!(b.view(2, 1, ..), ExprMut::from([1012, 1112, 1212].as_mut_slice()));
assert_eq!(a.view(1, 2..3, 3..), Expr::from(&[[1123], [1124]]));
assert_eq!(b.view(3.., 2..3, 1), ExprMut::from(&mut [[1123, 1124]]));
assert_eq!(DGrid::<usize, 3>::from_elem([3, 4, 5], 1)[..], [1; 60]);
assert_eq!(a, DGrid::<usize, 3>::from_fn([3, 4, 5], |i| 1000 + 100 * i[0] + 10 * i[1] + i[2]));
assert_eq!(b, DGrid::<usize, 3>::from_fn([5, 4, 3], |i| 1000 + 100 * i[2] + 10 * i[1] + i[0]));
assert_eq!(a.view(2, .., ..), a.axis_expr::<0>().into_iter().skip(2).next().unwrap());
assert_eq!(b.grid(2, .., ..), b.axis_expr_mut::<0>().into_iter().skip(2).next().unwrap());
assert_eq!(b.view(.., 2, ..), b.axis_expr::<1>().into_iter().skip(2).next().unwrap());
assert_eq!(a.grid(.., 2, ..), a.axis_expr_mut::<1>().into_iter().skip(2).next().unwrap());
assert_eq!(a.view(.., .., 2), a.axis_expr::<2>().into_iter().skip(2).next().unwrap());
assert_eq!(b.grid(.., .., 2), b.axis_expr_mut::<2>().into_iter().skip(2).next().unwrap());
assert_eq!(a.view(.., .., 2), a.outer_expr().into_iter().skip(2).next().unwrap());
assert_eq!(b.grid(.., .., 2), b.outer_expr_mut().into_iter().skip(2).next().unwrap());
assert_eq!(a.contains(&1111), true);
assert_eq!(a.view(1, 1.., 1..).contains(&9999), false);
assert_eq!(a.view(1.., 2.., 3).into_diag(0), expr![1123, 1233]);
assert_eq!(a.view(2, 1.., ..).diag(0), expr![1210, 1221, 1232]);
assert_eq!(a.view_mut(1, 2.., 3..).diag_mut(0), expr![1123, 1134]);
assert_eq!(a.view(.., .., 1).col(2), expr![1021, 1121, 1221]);
assert_eq!(a.view_mut(2, .., ..).col_mut(1), expr![1201, 1211, 1221, 1231]);
assert_eq!(a.view(.., .., 1).row(2), expr![1201, 1211, 1221, 1231]);
assert_eq!(a.view_mut(2, .., ..).row_mut(1), expr![1210, 1211, 1212, 1213, 1214]);
let mut r = a.clone().into_shape([5, 4, 3]);
let mut s = b.clone();
unsafe {
s.set_mapping(DenseMapping::new((Dyn(3), Dyn(4), Dyn(5))));
}
a.resize([4, 4, 4], 9999);
b.resize_with([4, 4, 4], || 9999);
assert_eq!(a.flatten().iter().sum::<usize>(), 213576);
assert_eq!(b.flatten().iter().sum::<usize>(), 213576);
assert_eq!(r.view(1.., 1.., 1..).dims(), [4, 3, 2]);
assert_eq!(s.view(1.., 1.., 1..).dims(), [2, 3, 4]);
assert_eq!(r.view(1.., 1.., 1..).strides(), [1, 5, 20]);
assert_eq!(s.view(1.., 1.., 1..).strides(), [1, 3, 12]);
assert_eq!(r.view(1.., 1.., 1..).view(2, 1, 0)[[]], 1032);
assert_eq!(s.view(1.., 1.., 1..).view(0, 1, 2)[[]], 1203);
assert_eq!(Grid::from_iter(0..10).grid(step(.., 2))[..], [0, 2, 4, 6, 8]);
assert_eq!(Grid::from_iter(0..10).grid(step(.., -2))[..], [9, 7, 5, 3, 1]);
assert!(Grid::from_iter(0..10).view(step(..0, isize::MAX)).is_empty());
assert!(Grid::from_iter(0..10).view_mut(step(..0, isize::MIN)).is_empty());
assert_eq!(Grid::from_iter(0..3).map(|x| 10 * x)[..], [0, 10, 20]);
assert_eq!(Grid::from_iter(0..3).apply(|x| 10 * x)[..], [0, 10, 20]);
assert_eq!(Grid::from_iter(0..3).zip_with(expr![3, 4, 5], |(x, y)| x + y)[..], [3, 5, 7]);
assert_eq!(to_slice!(a.view(..2, ..2, ..).split_at(1).0), [1000, 1100, 1010, 1110]);
assert_eq!(to_slice!(a.view(..2, .., ..2).split_axis_at::<1>(3).1), [1030, 1130, 1031, 1131]);
a.truncate(2);
assert_eq!(to_slice!(a.view(..2, ..2, ..)), [1000, 1100, 1010, 1110, 1001, 1101, 1011, 1111]);
r.flatten_mut().iter_mut().for_each(|x| *x *= 2);
s[..].iter_mut().for_each(|x| *x *= 2);
assert_eq!(r.flatten().iter().sum::<usize>(), 134040);
assert_eq!(s[..].iter().sum::<usize>(), 134040);
r.clear();
assert!(r.is_empty());
assert!(r.capacity() > 0);
r.shrink_to_fit();
assert!(r.capacity() == 0);
let mut t = s.clone();
s.reserve(60);
t.reserve_exact(60);
assert!(s.capacity() >= 120 && t.capacity() >= 120);
assert!(s.spare_capacity_mut().len() == s.capacity() - s.len());
s.shrink_to(60);
t.shrink_to_fit();
assert!(s.capacity() < 120 && t.capacity() < 120);
_ = t.try_reserve(usize::MAX).unwrap_err();
t.try_reserve_exact(60).unwrap();
s.append(&mut t.clone());
t.expand(&s.view(.., .., 5..));
assert_eq!(Grid::from_iter(s.into_shape([120])).as_ref(), t.into_vec());
let mut d = DGrid::<usize, 2>::from([[1, 2], [3, 4], [5, 6]]);
let e = d.drain(1..2).eval();
assert_eq!(d, Expr::from(&[[1, 2], [5, 6]]));
assert_eq!(e, Expr::from(&[[3, 4]]));
assert_eq!(grid![123].into_scalar(), Grid::from_elem((), 123)[[]]);
assert_eq!(DGrid::<i32, 3>::from([[[456; 0]; 3]; 0]).dims(), [0, 3, 0]);
assert_eq!(DGrid::<i32, 3>::from([[[456; 3]; 0]; 3]).dims(), [3, 0, 3]);
assert_eq!(expr![1, 2, 3].permute::<0>(), expr![1, 2, 3]);
assert_eq!(grid![[1, 2, 3], [4, 5, 6]].permute_mut::<0, 1>(), expr![[1, 2, 3], [4, 5, 6]]);
assert_eq!(grid![[1, 2, 3], [4, 5, 6]].permute_mut::<1, 0>(), expr![[1, 4], [2, 5], [3, 6]]);
let v = expr![[[1, 2, 3], [4, 5, 6]]];
assert_eq!(v.into_permuted::<0, 1, 2>(), expr![[[1, 2, 3], [4, 5, 6]]]);
assert_eq!(v.into_permuted::<0, 2, 1>(), expr![[[1, 2, 3]], [[4, 5, 6]]]);
assert_eq!(v.into_permuted::<1, 0, 2>(), expr![[[1, 4], [2, 5], [3, 6]]]);
assert_eq!(v.into_permuted::<1, 2, 0>(), expr![[[1, 4]], [[2, 5]], [[3, 6]]]);
assert_eq!(v.into_permuted::<2, 0, 1>(), expr![[[1], [2], [3]], [[4], [5], [6]]]);
assert_eq!(v.into_permuted::<2, 1, 0>(), expr![[[1], [4]], [[2], [5]], [[3], [6]]]);
assert_eq!(Array::<usize, ()>(123).into_scalar(), 123);
assert_eq!(array![1, 2, 3].into_shape((Const::<3>, Const::<1>)), expr![[1, 2, 3]]);
assert_eq!(array![1, 2, 3].into_shape((Const::<1>, Const::<3>)), expr![[1], [2], [3]]);
assert_eq!(array![[1, 2, 3], [4, 5, 6]], expr![[1, 2, 3], [4, 5, 6]]);
#[cfg(feature = "nightly")]
let u = DGrid::<u8, 1, AlignedAlloc<64>>::with_capacity_in(64, AlignedAlloc::new(Global));
#[cfg(feature = "nightly")]
assert_eq!(u.as_ptr() as usize % 64, 0);
}
#[test]
fn test_expr() {
let mut a = grid![[1, 2, 3], [4, 5, 6]];
assert_eq!(a.dims(), [3, 2]);
assert_eq!((&a + &expr![1, 2, 3]).eval()[..], [2, 4, 6, 5, 7, 9]);
assert_eq!((&expr![1, 2, 3] + &a).eval()[..], [2, 4, 6, 5, 7, 9]);
assert_eq!(format!("{:?}", a.axis_expr::<0>()), "AxisExpr(0, [[1, 2, 3], [4, 5, 6]])");
assert_eq!(format!("{:?}", a.outer_expr_mut()), "AxisExprMut(1, [[1, 2, 3], [4, 5, 6]])");
assert_eq!(format!("{:?}", a.cols()), "Lanes(0, [[1, 2, 3], [4, 5, 6]])");
assert_eq!(format!("{:?}", a.rows_mut()), "LanesMut(1, [[1, 2, 3], [4, 5, 6]])");
assert_eq!(format!("{:?}", a.clone().drain(1..)), "[[4, 5, 6]]");
assert_eq!(format!("{:?}", a.clone().into_expr()), "[[1, 2, 3], [4, 5, 6]]");
assert_eq!(format!("{:?}", expr::fill(1)), "Fill(1)");
assert_eq!(format!("{:?}", expr::fill_with(|| 1)), "FillWith");
assert_eq!(format!("{:?}", expr::from_elem([1, 2], 3)), "FromElem((Dyn(1), Dyn(2)), 3)");
assert_eq!(format!("{:?}", expr::from_fn([1, 2], |i| i)), "FromFn((Dyn(1), Dyn(2)))");
let e1 = format!("{:?}", a.expr().cloned().map(|x| x + 3));
let e2 = format!("{:?}", a.view(.., ..1).expr().zip(&a.view(.., 1..)));
let e3 = format!("{:?}", a.view_mut(.., 1..).expr_mut().enumerate());
assert_eq!(e1, "Map { expr: Cloned { expr: [[1, 2, 3], [4, 5, 6]] } }");
assert_eq!(e2, "Zip { a: [[1, 2, 3]], b: [[4, 5, 6]] }");
assert_eq!(e3, "Enumerate { expr: [[4, 5, 6]] }");
assert_eq!(format!("{:?}", a.view(.., 0).iter()), "Iter([1, 2, 3])");
assert_eq!(format!("{:?}", a.view_mut(.., 1).iter_mut()), "Iter([4, 5, 6])");
assert_eq!(format!("{:?}", a.view(1, ..).iter()), "Iter([2, 5])");
assert_eq!(format!("{:?}", a.view_mut(2, ..).iter_mut()), "Iter([3, 6])");
let b = a.expr().copied().map(|x| x + 3).eval();
assert_eq!(b, expr![[4, 5, 6], [7, 8, 9]]);
let mut c = grid![[1, 2], [3, 4], [5, 6]];
c.expand(grid![[7, 8], [9, 10]].into_expr());
_ = expr![11, 12].expr().cloned().eval_into(&mut c);
assert_eq!(c, expr![[1, 2], [3, 4], [5, 6], [7, 8], [9, 10], [11, 12]]);
c.assign(grid![[1; 2]; 6].into_expr());
assert_eq!(c, expr![[1; 2]; 6]);
c.assign(&expr![[2; 2]; 6]);
assert_eq!(c, expr![[2; 2]; 6]);
let d = expr![[(1, 5), (2, 6)], [(3, 5), (4, 6)]];
let e = [[([0, 0], 1), ([1, 0], 1)], [([0, 1], 1), ([1, 1], 1)], [([0, 2], 1), ([1, 2], 1)]];
assert_eq!(expr::zip(&expr![[1, 2], [3, 4]], &expr![5, 6]).map(|(x, y)| (*x, *y)).eval(), d);
assert_eq!(grid![[1; 2]; 3].into_expr().enumerate().eval(), Grid::from(e));
assert_eq!(a.cols().eval(), expr![expr![1, 2, 3], expr![4, 5, 6]]);
assert_eq!(a.cols_mut().eval(), expr![expr![1, 2, 3], expr![4, 5, 6]]);
assert_eq!(a.lanes::<0>().eval(), expr![expr![1, 2, 3], expr![4, 5, 6]]);
assert_eq!(a.lanes_mut::<1>().eval(), expr![expr![1, 4], expr![2, 5], expr![3, 6]]);
assert_eq!(a.rows().eval(), expr![expr![1, 4], expr![2, 5], expr![3, 6]]);
assert_eq!(a.rows_mut().eval(), expr![expr![1, 4], expr![2, 5], expr![3, 6]]);
}
#[test]
fn test_hash() {
let mut s1 = DefaultHasher::new();
let mut s2 = DefaultHasher::new();
DGrid::<usize, 3>::from([[[4], [5]], [[6], [7]], [[8], [9]]]).hash(&mut s1);
for i in 0..9 {
s2.write_usize(i + 1);
}
assert_eq!(s1.finish(), s2.finish());
}
#[test]
fn test_index() {
check_view::<Dense>();
check_view::<General>();
check_view::<Flat>();
check_view::<Strided>();
}
#[test]
fn test_macros() {
let grid1: Grid<usize, _> = grid![];
let grid2: Grid<usize, _> = grid![[]];
let grid3: Grid<usize, _> = grid![[[]]];
let grid4: Grid<usize, _> = grid![[[[]]]];
let grid5: Grid<usize, _> = grid![[[[[]]]]];
let grid6: Grid<usize, _> = grid![[[[[[]]]]]];
let view1: Expr<usize, _> = expr![];
let view2: Expr<usize, _> = expr![[]];
let view3: Expr<usize, _> = expr![[[]]];
let view4: Expr<usize, _> = expr![[[[]]]];
let view5: Expr<usize, _> = expr![[[[[]]]]];
let view6: Expr<usize, _> = expr![[[[[[]]]]]];
assert_eq!(grid1.dims(), [0]);
assert_eq!(grid2.dims(), [0, 1]);
assert_eq!(grid3.dims(), [0, 1, 1]);
assert_eq!(grid4.dims(), [0, 1, 1, 1]);
assert_eq!(grid5.dims(), [0, 1, 1, 1, 1]);
assert_eq!(grid6.dims(), [0, 1, 1, 1, 1, 1]);
assert_eq!(view1.dims(), [0]);
assert_eq!(view2.dims(), [0, 1]);
assert_eq!(view3.dims(), [0, 1, 1]);
assert_eq!(view4.dims(), [0, 1, 1, 1]);
assert_eq!(view5.dims(), [0, 1, 1, 1, 1]);
assert_eq!(view6.dims(), [0, 1, 1, 1, 1, 1]);
assert_eq!(grid![1, 2, 3], Grid::from([1, 2, 3]));
assert_eq!(grid![[1, 2, 3], [4, 5, 6]], Grid::from([[1, 2, 3], [4, 5, 6]]));
assert_eq!(grid![[[1, 2, 3], [4, 5, 6]]], Grid::from([[[1, 2, 3], [4, 5, 6]]]));
assert_eq!(grid![[[[1, 2, 3], [4, 5, 6]]]], Grid::from([[[[1, 2, 3], [4, 5, 6]]]]));
assert_eq!(grid![[[[[1, 2, 3], [4, 5, 6]]]]], Grid::from([[[[[1, 2, 3], [4, 5, 6]]]]]));
assert_eq!(grid![[[[[[1, 2, 3], [4, 5, 6]]]]]], Grid::from([[[[[[1, 2, 3], [4, 5, 6]]]]]]));
assert_eq!(expr![1, 2, 3], Expr::from(&[1, 2, 3]));
assert_eq!(expr![[1, 2, 3], [4, 5, 6]], Expr::from(&[[1, 2, 3], [4, 5, 6]]));
assert_eq!(expr![[[1, 2, 3], [4, 5, 6]]], Expr::from(&[[[1, 2, 3], [4, 5, 6]]]));
assert_eq!(expr![[[[1, 2, 3], [4, 5, 6]]]], Expr::from(&[[[[1, 2, 3], [4, 5, 6]]]]));
assert_eq!(expr![[[[[1, 2, 3], [4, 5, 6]]]]], Expr::from(&[[[[[1, 2, 3], [4, 5, 6]]]]]));
assert_eq!(expr![[[[[[1, 2, 3], [4, 5, 6]]]]]], Expr::from(&[[[[[[1, 2, 3], [4, 5, 6]]]]]]));
assert_eq!(grid![0; 1], Grid::from_elem([1], 0));
assert_eq!(grid![[0; 1]; 2], Grid::from_elem([1, 2], 0));
assert_eq!(grid![[[0; 1]; 2]; 3], Grid::from_elem([1, 2, 3], 0));
assert_eq!(grid![[[[0; 1]; 2]; 3]; 4], Grid::from_elem([1, 2, 3, 4], 0));
assert_eq!(grid![[[[[0; 1]; 2]; 3]; 4]; 5], Grid::from_elem([1, 2, 3, 4, 5], 0));
assert_eq!(grid![[[[[[0; 1]; 2]; 3]; 4]; 5]; 6], Grid::from_elem([1, 2, 3, 4, 5, 6], 0));
assert_eq!(expr![0; 1], Expr::from(&[0; 1]));
assert_eq!(expr![[0; 1]; 2], Expr::from(&[[0; 1]; 2]));
assert_eq!(expr![[[0; 1]; 2]; 3], Expr::from(&[[[0; 1]; 2]; 3]));
assert_eq!(expr![[[[0; 1]; 2]; 3]; 4], Expr::from(&[[[[0; 1]; 2]; 3]; 4]));
assert_eq!(expr![[[[[0; 1]; 2]; 3]; 4]; 5], Expr::from(&[[[[[0; 1]; 2]; 3]; 4]; 5]));
assert_eq!(expr![[[[[[0; 1]; 2]; 3]; 4]; 5]; 6], Expr::from(&[[[[[[0; 1]; 2]; 3]; 4]; 5]; 6]));
}
#[test]
fn test_mapping() {
let d = DenseMapping::new((Const::<1>, Const::<2>, Const::<3>));
let f = FlatMapping::new((Const::<1>, Dyn(2), Const::<3>), 4);
let g = GeneralMapping::new((Dyn(1), Const::<2>, Dyn(3)), [4, 5]);
let s = StridedMapping::new((Dyn(1), Dyn(2), Dyn(3)), [4, 5, 6]);
assert_eq!(d.is_contiguous(), true);
assert_eq!(f.is_empty(), false);
assert_eq!(g.is_uniformly_strided(), false);
assert_eq!(s.len(), 6);
assert_eq!(d.rank(), 3);
assert_eq!(f.dim(2), 3);
assert_eq!(d.dims(), [1, 2, 3]);
assert_eq!(g.stride(0), 1);
assert_eq!(s.strides(), [4, 5, 6]);
let x = format!("{:?}", d);
let y = format!("{:?}", f);
let z = format!("{:?}", g);
let w = format!("{:?}", s);
assert_eq!(x, "DenseMapping { shape: (Const(1), Const(2), Const(3)) }");
assert_eq!(y, "FlatMapping { shape: (Const(1), Dyn(2), Const(3)), inner_stride: 4 }");
assert_eq!(z, "GeneralMapping { shape: (Dyn(1), Const(2), Dyn(3)), outer_strides: [4, 5] }");
assert_eq!(w, "StridedMapping { shape: (Dyn(1), Dyn(2), Dyn(3)), strides: [4, 5, 6] }");
}
#[test]
fn test_ops() {
let mut a = DGrid::<i32, 2>::from([[1, 2, 3], [4, 5, 6]]);
let b = DGrid::<i32, 2>::from([[9, 8, 7], [6, 5, 4]]);
a -= expr::fill(1);
a -= &b;
a -= b.expr();
*a -= expr::fill(1);
*a -= &b;
*a -= b.expr();
assert_eq!(a, Grid::from([[-37, -32, -27], [-22, -17, -12]]));
a = a - expr::fill(1);
a = a - &b;
a = a - b.expr();
a = expr::fill(1) - a;
a = &b - a;
a = b.expr() - a;
assert_eq!(a, Grid::from([[57, 50, 43], [36, 29, 22]]));
a = (&a - &b).eval();
a = (&a - b.expr()).eval();
a = (a.expr() - &b).eval();
a = (a.expr() - b.expr()).eval();
assert_eq!(a, Grid::from([[21, 18, 15], [12, 9, 6]]));
a = (&a - expr::fill(1)).eval();
a = (a.expr() - expr::fill(1)).eval();
a = (expr::fill(1) - &a).eval();
a = (expr::fill(1) - a.expr()).eval();
assert_eq!(a, Grid::from([[19, 16, 13], [10, 7, 4]]));
a = -a;
a = (-&a).eval();
a = (-a.expr()).eval();
assert_eq!(a, Grid::from([[-19, -16, -13], [-10, -7, -4]]));
assert!(a == a && *a == a && a == *a && *a == *a);
assert!(a == a.expr() && a.expr() == a && a.expr() == a.expr());
assert!(a == a.clone().expr_mut() && a.clone().expr_mut() == a);
assert!(a.clone().expr_mut() == a.clone().expr_mut());
let c = expr::fill_with(|| 1usize) + expr::from_elem([2, 3], 4);
let c = c + expr::from_fn([2, 3], |x| x[0] + x[1]);
assert_eq!(c.eval(), Grid::from([[5, 6], [6, 7], [7, 8]]));
}
#[cfg(feature = "serde")]
#[test]
fn test_serde() {
assert_tokens(&Array::<i32, ()>(123), &[Token::I32(123)]);
assert_tokens(
&Array::<i32, (Const<3>, Const<0>)>([]),
&[Token::Seq { len: Some(0) }, Token::SeqEnd],
);
assert_tokens(
&Array::<i32, (Const<0>, Const<3>)>([[], [], []]),
&[
Token::Seq { len: Some(3) },
Token::Seq { len: Some(0) },
Token::SeqEnd,
Token::Seq { len: Some(0) },
Token::SeqEnd,
Token::Seq { len: Some(0) },
Token::SeqEnd,
Token::SeqEnd,
],
);
assert_tokens(
&Array::<i32, (Const<3>, Const<2>, Const<1>)>([[[4, 5, 6], [7, 8, 9]]]),
&[
Token::Seq { len: Some(1) },
Token::Seq { len: Some(2) },
Token::Seq { len: Some(3) },
Token::I32(4),
Token::I32(5),
Token::I32(6),
Token::SeqEnd,
Token::Seq { len: Some(3) },
Token::I32(7),
Token::I32(8),
Token::I32(9),
Token::SeqEnd,
Token::SeqEnd,
Token::SeqEnd,
],
);
assert_tokens(&Grid::from_elem((), 123), &[Token::I32(123)]);
assert_tokens(
&Grid::<i32, (Const<3>, Dyn)>::new(),
&[Token::Seq { len: Some(0) }, Token::SeqEnd],
);
assert_tokens(
&Grid::<i32, (Dyn, Const<3>)>::new(),
&[
Token::Seq { len: Some(3) },
Token::Seq { len: Some(0) },
Token::SeqEnd,
Token::Seq { len: Some(0) },
Token::SeqEnd,
Token::Seq { len: Some(0) },
Token::SeqEnd,
Token::SeqEnd,
],
);
assert_tokens(
&DGrid::<i32, 3>::from([[[4, 5, 6], [7, 8, 9]]]),
&[
Token::Seq { len: Some(1) },
Token::Seq { len: Some(2) },
Token::Seq { len: Some(3) },
Token::I32(4),
Token::I32(5),
Token::I32(6),
Token::SeqEnd,
Token::Seq { len: Some(3) },
Token::I32(7),
Token::I32(8),
Token::I32(9),
Token::SeqEnd,
Token::SeqEnd,
Token::SeqEnd,
],
);
}
#[test]
fn test_traits() {
let x = vec![1, 2, 3];
let ptr = x.as_ptr();
let y = x.into_cloned();
let z: Vec<usize> = (&y).into_cloned();
assert_eq!(ptr, y.as_ptr());
assert_ne!(ptr, z.as_ptr());
let mut u = vec![];
let mut v = vec![];
y.clone_to(&mut u);
(&u).clone_to(&mut v);
assert_eq!(ptr, u.as_ptr());
assert_ne!(ptr, v.as_ptr());
}