#![allow(non_snake_case)]

// `s![1..-1, ..]` etc. — ndarray's `s!` macro uses Python-style negative

// indexing. Clippy can't see through the macro and reads `1..-1` as a plain

// (empty) Rust range; the actual semantics are correct.

#![allow(clippy::reversed_empty_ranges)]

#![allow(

clippy::many_single_char_names, clippy::deref_addrof, clippy::unreadable_literal, clippy::float_cmp

)]

use approx::assert_relative_eq;

use core::panic;

use defmac::defmac;

#[allow(deprecated)]

use itertools::{zip, Itertools};

use ndarray::indices;

use ndarray::prelude::*;

use ndarray::ErrorKind;

use ndarray::{arr3, rcarr2};

use ndarray::{Slice, SliceInfo, SliceInfoElem};

use num_complex::Complex;

use std::convert::TryFrom;

macro_rules! assert_panics {

($body:expr) => {

if let Ok(v) = ::std::panic::catch_unwind(|| $body) {

panic!("assertion failed: should_panic; \

non-panicking result: {:?}", v);

}

};

($body:expr, $($arg:tt)*) => {

if let Ok(_) = ::std::panic::catch_unwind(|| $body) {

panic!($($arg)*);

}

};

}

#[test]

fn test_matmul_arcarray() {

let mut A = ArcArray::<usize, _>::zeros((2, 3));

for (i, elt) in A.iter_mut().enumerate() {

*elt = i;

}

let mut B = ArcArray::<usize, _>::zeros((3, 4));

for (i, elt) in B.iter_mut().enumerate() {

*elt = i;

}

let c = A.dot(&B);

println!("A = \n{:?}", A);

println!("B = \n{:?}", B);

println!("A x B = \n{:?}", c);

unsafe {

let result = ArcArray::from_shape_vec_unchecked((2, 4), vec![20, 23, 26, 29, 56, 68, 80, 92]);

assert_eq!(c.shape(), result.shape());

assert!(c.iter().zip(result.iter()).all(|(a, b)| a == b));

assert!(c == result);

}

}

#[allow(unused)]

fn arrayview_shrink_lifetime<'a, 'b: 'a>(view: ArrayView1<'b, f64>) -> ArrayView1<'a, f64> {

view.reborrow()

}

#[allow(unused)]

fn arrayviewmut_shrink_lifetime<'a, 'b: 'a>(view: ArrayViewMut1<'b, f64>) -> ArrayViewMut1<'a, f64> {

view.reborrow()

}

#[test]

fn test_mat_mul() {

// smoke test, a big matrix multiplication of uneven size

let (n, m) = (45, 33);

let a = Array::from_iter(0..(n * m))

.into_shape_with_order((n, m))

.unwrap();

let b = Array::eye(m);

assert_eq!(a.dot(&b), a);

let c = Array::eye(n);

assert_eq!(c.dot(&a), a);

}

#[deny(unsafe_code)]

#[test]

fn test_slice() {

let mut A = ArcArray::<usize, _>::zeros((3, 4, 5));

for (i, elt) in A.iter_mut().enumerate() {

*elt = i;

}

let vi = A.slice(s![1.., ..;2, NewAxis, Slice::new(0, None, 2)]);

assert_eq!(vi.shape(), &[2, 2, 1, 3]);

let vi = A.slice(s![.., .., ..]);

assert_eq!(vi.shape(), A.shape());

assert!(vi.iter().zip(A.iter()).all(|(a, b)| a == b));

}

#[deny(unsafe_code)]

#[test]

fn test_slice_ix0() {

let arr = arr0(5);

assert_eq!(arr.slice(s![]), aview0(&5));

}

#[test]

fn test_slice_edge_cases() {

let mut arr = Array3::<u8>::zeros((3, 4, 5));

arr.slice_collapse(s![0..0;-1, .., ..]);

assert_eq!(arr.shape(), &[0, 4, 5]);

let mut arr = Array2::<u8>::from_shape_vec((1, 1).strides((10, 1)), vec![5]).unwrap();

arr.slice_collapse(s![1..1, ..]);

assert_eq!(arr.shape(), &[0, 1]);

}

#[test]

fn test_slice_inclusive_range() {

let arr = array![[1, 2, 3], [4, 5, 6]];

assert_eq!(arr.slice(s![1..=1, 1..=2]), array![[5, 6]]);

assert_eq!(arr.slice(s![1..=-1, -2..=2;-1]), array![[6, 5]]);

assert_eq!(arr.slice(s![0..=-1, 0..=2;2]), array![[1, 3], [4, 6]]);

}

/// Test that the compiler can infer a type for a sliced array from the

/// arguments to `s![]`.

///

/// This test relies on the fact that `.dot()` is implemented for both

/// `ArrayView1` and `ArrayView2`, so the compiler needs to determine which

/// type is the correct result for the `.slice()` call.

#[test]

fn test_slice_infer() {

let a = array![1., 2.];

let b = array![[3., 4.], [5., 6.]];

b.slice(s![..-1, ..]).dot(&a);

// b.slice(s![0, ..]).dot(&a);

}

#[test]

fn test_slice_with_many_dim() {

let mut A = ArcArray::<usize, _>::zeros(&[3, 1, 4, 1, 3, 2, 1][..]);

for (i, elt) in A.iter_mut().enumerate() {

*elt = i;

}

let vi = A.slice(s![..2, NewAxis, .., ..;2, NewAxis, ..1, ..1, 1.., ..]);

let new_shape = &[2, 1, 1, 2, 1, 1, 1, 1, 1][..];

assert_eq!(vi.shape(), new_shape);

let correct = array![

[A[&[0, 0, 0, 0, 0, 1, 0][..]], A[&[0, 0, 2, 0, 0, 1, 0][..]]],

[A[&[1, 0, 0, 0, 0, 1, 0][..]], A[&[1, 0, 2, 0, 0, 1, 0][..]]]

]

.into_shape_with_order(new_shape)

.unwrap();

assert_eq!(vi, correct);

let vi = A.slice(s![..2, 0, ..;2, 0, 0, 1, 0]);

assert_eq!(vi.shape(), &[2, 2][..]);

let correct = array![

[A[&[0, 0, 0, 0, 0, 1, 0][..]], A[&[0, 0, 2, 0, 0, 1, 0][..]]],

[A[&[1, 0, 0, 0, 0, 1, 0][..]], A[&[1, 0, 2, 0, 0, 1, 0][..]]]

];

assert_eq!(vi, correct);

}

#[test]

fn test_slice_range_variable() {

let range = 1..4;

let arr = array![0, 1, 2, 3, 4];

assert_eq!(arr.slice(s![range]), array![1, 2, 3]);

}

#[test]

fn test_slice_args_eval_range_once() {

let mut eval_count = 0;

{

let mut range = || {

eval_count += 1;

1..4

};

let arr = array![0, 1, 2, 3, 4];

assert_eq!(arr.slice(s![range()]), array![1, 2, 3]);

}

assert_eq!(eval_count, 1);

}

#[test]

fn test_slice_args_eval_step_once() {

let mut eval_count = 0;

{

let mut step = || {

eval_count += 1;

-1

};

let arr = array![0, 1, 2, 3, 4];

assert_eq!(arr.slice(s![1..4;step()]), array![3, 2, 1]);

}

assert_eq!(eval_count, 1);

}

#[test]

fn test_slice_array_fixed() {

let mut arr = Array3::<f64>::zeros((5, 2, 5));

let info = s![1.., 1, NewAxis, ..;2];

arr.slice(info);

arr.slice_mut(info);

arr.view().slice_move(info);

let info2 = s![1.., 1, ..;2];

arr.view().slice_collapse(info2);

}

#[test]

fn test_slice_dyninput_array_fixed() {

let mut arr = Array3::<f64>::zeros((5, 2, 5)).into_dyn();

let info = s![1.., 1, NewAxis, ..;2];

arr.slice(info);

arr.slice_mut(info);

arr.view().slice_move(info);

let info2 = s![1.., 1, ..;2];

arr.view().slice_collapse(info2);

}

#[test]

fn test_slice_array_dyn() {

let mut arr = Array3::<f64>::zeros((5, 2, 5));

let info = SliceInfo::<_, Ix3, IxDyn>::try_from([

SliceInfoElem::from(1..),

SliceInfoElem::from(1),

SliceInfoElem::from(NewAxis),

SliceInfoElem::from(Slice::from(..).step_by(2)),

])

.unwrap();

arr.slice(info);

arr.slice_mut(info);

arr.view().slice_move(info);

let info2 = SliceInfo::<_, Ix3, IxDyn>::try_from([

SliceInfoElem::from(1..),

SliceInfoElem::from(1),

SliceInfoElem::from(Slice::from(..).step_by(2)),

])

.unwrap();

arr.view().slice_collapse(info2);

}

#[test]

fn test_slice_dyninput_array_dyn() {

let mut arr = Array3::<f64>::zeros((5, 2, 5)).into_dyn();

let info = SliceInfo::<_, Ix3, IxDyn>::try_from([

SliceInfoElem::from(1..),

SliceInfoElem::from(1),

SliceInfoElem::from(NewAxis),

SliceInfoElem::from(Slice::from(..).step_by(2)),

])

.unwrap();

arr.slice(info);

arr.slice_mut(info);

arr.view().slice_move(info);

let info2 = SliceInfo::<_, Ix3, IxDyn>::try_from([

SliceInfoElem::from(1..),

SliceInfoElem::from(1),

SliceInfoElem::from(Slice::from(..).step_by(2)),

])

.unwrap();

arr.view().slice_collapse(info2);

}

#[test]

fn test_slice_dyninput_vec_fixed() {

let mut arr = Array3::<f64>::zeros((5, 2, 5)).into_dyn();

let info = &SliceInfo::<_, Ix3, Ix3>::try_from(vec![

SliceInfoElem::from(1..),

SliceInfoElem::from(1),

SliceInfoElem::from(NewAxis),

SliceInfoElem::from(Slice::from(..).step_by(2)),

])

.unwrap();

arr.slice(info);

arr.slice_mut(info);

arr.view().slice_move(info);

let info2 = SliceInfo::<_, Ix3, Ix2>::try_from(vec![

SliceInfoElem::from(1..),

SliceInfoElem::from(1),

SliceInfoElem::from(Slice::from(..).step_by(2)),

])

.unwrap();

arr.view().slice_collapse(info2);

}

#[test]

fn test_slice_dyninput_vec_dyn() {

let mut arr = Array3::<f64>::zeros((5, 2, 5)).into_dyn();

let info = &SliceInfo::<_, Ix3, IxDyn>::try_from(vec![

SliceInfoElem::from(1..),

SliceInfoElem::from(1),

SliceInfoElem::from(NewAxis),

SliceInfoElem::from(Slice::from(..).step_by(2)),

])

.unwrap();

arr.slice(info);

arr.slice_mut(info);

arr.view().slice_move(info);

let info2 = SliceInfo::<_, Ix3, IxDyn>::try_from(vec![

SliceInfoElem::from(1..),

SliceInfoElem::from(1),

SliceInfoElem::from(Slice::from(..).step_by(2)),

])

.unwrap();

arr.view().slice_collapse(info2);

}

#[test]

fn test_slice_with_subview_and_new_axis() {

let mut arr = ArcArray::<usize, _>::zeros((3, 5, 4));

for (i, elt) in arr.iter_mut().enumerate() {

*elt = i;

}

let vi = arr.slice(s![NewAxis, 1.., 2, ..;2]);

assert_eq!(vi.shape(), &[1, 2, 2]);

assert!(vi

.iter()

.zip(

arr.index_axis(Axis(1), 2)

.slice(s![1.., ..;2])

.insert_axis(Axis(0))

.iter()

)

.all(|(a, b)| a == b));

let vi = arr.slice(s![1, NewAxis, 2, ..;2]);

assert_eq!(vi.shape(), &[1, 2]);

assert!(vi

.iter()

.zip(

arr.index_axis(Axis(0), 1)

.index_axis(Axis(0), 2)

.slice(s![..;2])

.insert_axis(Axis(0))

.iter()

)

.all(|(a, b)| a == b));

let vi = arr.slice(s![1, 2, 3]);

assert_eq!(vi.shape(), &[]);

assert_eq!(vi, Array0::from_elem((), arr[(1, 2, 3)]));

}

#[test]

fn test_slice_collapse_with_indices() {

let mut arr = ArcArray::<usize, _>::zeros((3, 5, 4));

for (i, elt) in arr.iter_mut().enumerate() {

*elt = i;

}

{

let mut vi = arr.view();

vi.slice_collapse(s![1.., 2, ..;2]);

assert_eq!(vi.shape(), &[2, 1, 2]);

assert!(vi

.iter()

.zip(arr.slice(s![1.., 2..3, ..;2]).iter())

.all(|(a, b)| a == b));

let mut vi = arr.view();

vi.slice_collapse(s![1, 2, ..;2]);

assert_eq!(vi.shape(), &[1, 1, 2]);

assert!(vi

.iter()

.zip(arr.slice(s![1..2, 2..3, ..;2]).iter())

.all(|(a, b)| a == b));

let mut vi = arr.view();

vi.slice_collapse(s![1, 2, 3]);

assert_eq!(vi.shape(), &[1, 1, 1]);

assert_eq!(vi, Array3::from_elem((1, 1, 1), arr[(1, 2, 3)]));

}

// Do it to the ArcArray itself

let elem = arr[(1, 2, 3)];

let mut vi = arr;

vi.slice_collapse(s![1, 2, 3]);

assert_eq!(vi.shape(), &[1, 1, 1]);

assert_eq!(vi, Array3::from_elem((1, 1, 1), elem));

}

#[test]

#[should_panic]

fn test_slice_collapse_with_newaxis() {

let mut arr = Array2::<u8>::zeros((2, 3));

arr.slice_collapse(s![0, 0, NewAxis]);

}

#[test]

fn test_multislice() {

macro_rules! do_test {

($arr:expr, $($s:expr),*) => {

{

let arr = $arr;

let copy = arr.clone();

assert_eq!(

arr.multi_slice_mut(($($s,)*)),

($(copy.clone().slice_mut($s),)*)

);

}

};

}

let mut arr = Array1::from_iter(0..48)

.into_shape_with_order((8, 6))

.unwrap();

assert_eq!((arr.clone().view_mut(),), arr.multi_slice_mut((s![.., ..],)),);

assert_eq!(arr.multi_slice_mut(()), ());

do_test!(&mut arr, s![0, ..]);

do_test!(&mut arr, s![0, ..], s![1, ..]);

do_test!(&mut arr, s![0, ..], s![-1, ..]);

do_test!(&mut arr, s![0, ..], s![1.., ..]);

do_test!(&mut arr, s![1, ..], s![..;2, ..]);

do_test!(&mut arr, s![..2, ..], s![2.., ..]);

do_test!(&mut arr, s![1..;2, ..], s![..;2, ..]);

do_test!(&mut arr, s![..;-2, ..], s![..;2, ..]);

do_test!(&mut arr, s![..;12, ..], s![3..;3, ..]);

do_test!(&mut arr, s![3, ..], s![..-1;-2, ..]);

do_test!(&mut arr, s![0, ..], s![1, ..], s![2, ..]);

do_test!(&mut arr, s![0, ..], s![1, ..], s![2, ..], s![3, ..]);

}

#[test]

fn test_multislice_intersecting() {

assert_panics!({

let mut arr = Array2::<u8>::zeros((8, 6));

arr.multi_slice_mut((s![3, .., NewAxis], s![3, ..]));

});

assert_panics!({

let mut arr = Array2::<u8>::zeros((8, 6));

arr.multi_slice_mut((s![3, ..], s![3.., ..]));

});

assert_panics!({

let mut arr = Array2::<u8>::zeros((8, 6));

arr.multi_slice_mut((s![3, ..], s![..;3, NewAxis, ..]));

});

assert_panics!({

let mut arr = Array2::<u8>::zeros((8, 6));

arr.multi_slice_mut((s![..;6, ..], s![3..;3, ..]));

});

assert_panics!({

let mut arr = Array2::<u8>::zeros((8, 6));

arr.multi_slice_mut((s![2, ..], s![..-1;-2, ..]));

});

assert_panics!({

let mut arr = Array2::<u8>::zeros((8, 6));

arr.multi_slice_mut((s![4, ..], s![3, ..], s![3, ..]));

});

assert_panics!({

let mut arr = Array2::<u8>::zeros((8, 6));

arr.multi_slice_mut((s![3, ..], s![4, ..], s![3, ..]));

});

assert_panics!({

let mut arr = Array2::<u8>::zeros((8, 6));

arr.multi_slice_mut((s![3, ..], s![3, ..], s![4, ..]));

});

assert_panics!({

let mut arr = Array2::<u8>::zeros((8, 6));

arr.multi_slice_mut((s![3, ..], s![3, ..], s![4, ..], s![3, ..]));

});

}

#[should_panic]

#[test]

fn index_out_of_bounds() {

let mut a = Array::<i32, _>::zeros((3, 4));

a[[3, 2]] = 1;

}

#[should_panic]

#[test]

fn slice_oob() {

let a = ArcArray::<i32, _>::zeros((3, 4));

let _vi = a.slice(s![..10, ..]);

}

#[should_panic]

#[test]

fn slice_axis_oob() {

let a = ArcArray::<i32, _>::zeros((3, 4));

let _vi = a.slice_axis(Axis(0), Slice::new(0, Some(10), 1));

}

#[should_panic]

#[test]

fn slice_wrong_dim() {

let a = ArcArray::<i32, _>::zeros(vec![3, 4, 5]);

let _vi = a.slice(s![.., ..]);

}

#[test]

fn test_index() {

let mut A = ArcArray::<usize, _>::zeros((2, 3));

for (i, elt) in A.iter_mut().enumerate() {

*elt = i;

}

#[allow(deprecated)]

for ((i, j), a) in zip(indices((2, 3)), &A) {

assert_eq!(*a, A[[i, j]]);

}

let vi = A.slice(s![1.., ..;2]);

let mut it = vi.iter();

#[allow(deprecated)]

for ((i, j), x) in zip(indices((1, 2)), &mut it) {

assert_eq!(*x, vi[[i, j]]);

}

assert!(it.next().is_none());

}

#[test]

fn test_index_arrays() {

let a = Array1::from_iter(0..12);

assert_eq!(a[1], a[[1]]);

let v = a.view().into_shape_with_order((3, 4)).unwrap();

assert_eq!(a[1], v[[0, 1]]);

let w = v.into_shape_with_order((2, 2, 3)).unwrap();

assert_eq!(a[1], w[[0, 0, 1]]);

}

#[test]

#[allow(clippy::assign_op_pattern)]

fn test_add() {

let mut A = ArcArray::<usize, _>::zeros((2, 2));

for (i, elt) in A.iter_mut().enumerate() {

*elt = i;

}

let B = A.clone();

A = A + &B;

assert_eq!(A[[0, 0]], 0);

assert_eq!(A[[0, 1]], 2);

assert_eq!(A[[1, 0]], 4);

assert_eq!(A[[1, 1]], 6);

}

#[test]

fn test_multidim() {

let mut mat = ArcArray::zeros(2 * 3 * 4 * 5 * 6)

.into_shape_with_order((2, 3, 4, 5, 6))

.unwrap();

mat[(0, 0, 0, 0, 0)] = 22u8;

{

for (i, elt) in mat.iter_mut().enumerate() {

*elt = i as u8;

}

}

assert_eq!(mat.shape(), &[2, 3, 4, 5, 6]);

}

/*

array([[[ 7, 6],

[ 5, 4],

[ 3, 2],

[ 1, 0]],

[[15, 14],

[13, 12],

[11, 10],

[ 9, 8]]])

*/

#[test]

fn test_negative_stride_arcarray() {

let mut mat = ArcArray::zeros((2, 4, 2));

mat[[0, 0, 0]] = 1.0f32;

for (i, elt) in mat.iter_mut().enumerate() {

*elt = i as f32;

}

{

let vi = mat.slice(s![.., ..;-1, ..;-1]);

assert_eq!(vi.shape(), &[2, 4, 2]);

// Test against sequential iterator

let seq = [7f32, 6., 5., 4., 3., 2., 1., 0., 15., 14., 13., 12., 11., 10., 9., 8.];

for (a, b) in vi.iter().zip(seq.iter()) {

assert_eq!(*a, *b);

}

}

{

let vi = mat.slice(s![.., ..;-5, ..]);

let seq = [6., 7., 14., 15.];

for (a, b) in vi.iter().zip(seq.iter()) {

assert_eq!(*a, *b);

}

}

}

#[test]

fn test_cow() {

let mut mat = ArcArray::zeros((2, 2));

mat[[0, 0]] = 1;

let n = mat.clone();

mat[[0, 1]] = 2;

mat[[1, 0]] = 3;

mat[[1, 1]] = 4;

assert_eq!(mat[[0, 0]], 1);

assert_eq!(mat[[0, 1]], 2);

assert_eq!(n[[0, 0]], 1);

assert_eq!(n[[0, 1]], 0);

assert_eq!(n.get((0, 1)), Some(&0));

let mut rev = mat.into_shape_with_order(4).unwrap();

rev.slice_collapse(s![..;-1]);

assert_eq!(rev[0], 4);

assert_eq!(rev[1], 3);

assert_eq!(rev[2], 2);

assert_eq!(rev[3], 1);

let before = rev.clone();

// mutation

rev[0] = 5;

assert_eq!(rev[0], 5);

assert_eq!(rev[1], 3);

assert_eq!(rev[2], 2);

assert_eq!(rev[3], 1);

assert_eq!(before[0], 4);

assert_eq!(before[1], 3);

assert_eq!(before[2], 2);

assert_eq!(before[3], 1);

}

#[test]

fn test_cow_shrink() {

// A test for clone-on-write in the case that

// mutation shrinks the array and gives it different strides

//

let mut mat = ArcArray::zeros((2, 3));

//mat.slice_collapse(s![.., ..;2]);

mat[[0, 0]] = 1;

let n = mat.clone();

mat[[0, 1]] = 2;

mat[[0, 2]] = 3;

mat[[1, 0]] = 4;

mat[[1, 1]] = 5;

mat[[1, 2]] = 6;

assert_eq!(mat[[0, 0]], 1);

assert_eq!(mat[[0, 1]], 2);

assert_eq!(n[[0, 0]], 1);

assert_eq!(n[[0, 1]], 0);

assert_eq!(n.get((0, 1)), Some(&0));

// small has non-C strides this way

let mut small = mat.into_shape_with_order(6).unwrap();

small.slice_collapse(s![4..;-1]);

assert_eq!(small[0], 6);

assert_eq!(small[1], 5);

let before = small.clone();

// mutation

// small gets back C strides in CoW.

small[1] = 9;

assert_eq!(small[0], 6);

assert_eq!(small[1], 9);

assert_eq!(before[0], 6);

assert_eq!(before[1], 5);

}

#[test]

fn test_sub() {

let mat = Array::from_iter(0..16)

.into_shape_with_order((2, 4, 2))

.unwrap();

let s1 = mat.index_axis(Axis(0), 0);

let s2 = mat.index_axis(Axis(0), 1);

assert_eq!(s1.shape(), &[4, 2]);

assert_eq!(s2.shape(), &[4, 2]);

let n = Array::from_iter(8..16)

.into_shape_with_order((4, 2))

.unwrap();

assert_eq!(n, s2);

let m = Array::from(vec![2, 3, 10, 11])

.into_shape_with_order((2, 2))

.unwrap();

assert_eq!(m, mat.index_axis(Axis(1), 1));

}

#[should_panic]

#[test]

fn test_sub_oob_1() {

let mat = Array::from_iter(0..16)

.into_shape_with_order((2, 4, 2))

.unwrap();

mat.index_axis(Axis(0), 2);

}

#[test]

#[cfg(feature = "approx")]

fn test_select() {

use approx::assert_abs_diff_eq;

// test for 2-d array

let x = arr2(&[[0., 1.], [1., 0.], [1., 0.], [1., 0.], [1., 0.], [0., 1.], [0., 1.]]);

let r = x.select(Axis(0), &[1, 3, 5]);

let c = x.select(Axis(1), &[1]);

let r_target = arr2(&[[1., 0.], [1., 0.], [0., 1.]]);

let c_target = arr2(&[[1., 0., 0., 0., 0., 1., 1.]]);

assert_abs_diff_eq!(r, r_target);

assert_abs_diff_eq!(c, c_target.t());

// test for 3-d array

let y = arr3(&[[[1., 2., 3.], [1.5, 1.5, 3.]], [[1., 2., 8.], [1., 2.5, 3.]]]);

let r = y.select(Axis(1), &[1]);

let c = y.select(Axis(2), &[1]);

let r_target = arr3(&[[[1.5, 1.5, 3.]], [[1., 2.5, 3.]]]);

let c_target = arr3(&[[[2.], [1.5]], [[2.], [2.5]]]);

assert_abs_diff_eq!(r, r_target);

assert_abs_diff_eq!(c, c_target);

}

#[test]

fn test_select_1d() {

let x = arr1(&[0, 1, 2, 3, 4, 5, 6]);

let r1 = x.select(Axis(0), &[1, 3, 4, 2, 2, 5]);

assert_eq!(r1, arr1(&[1, 3, 4, 2, 2, 5]));

// select nothing

let r2 = x.select(Axis(0), &[]);

assert_eq!(r2, arr1(&[]));

// select nothing from empty

let r3 = r2.select(Axis(0), &[]);

assert_eq!(r3, arr1(&[]));

}

#[test]

fn diag() {

let d = arr2(&[[1., 2., 3.0f32]]).into_diag();

assert_eq!(d.dim(), 1);

let a = arr2(&[[1., 2., 3.0f32], [0., 0., 0.]]);

let d = a.view().into_diag();

assert_eq!(d.dim(), 2);

let d = arr2::<f32, 0>(&[[]]).into_diag();

assert_eq!(d.dim(), 0);

let d = ArcArray::<f32, _>::zeros(()).into_diag();

assert_eq!(d.dim(), 1);

}

/// Check that the merged shape is correct.

///

/// Note that this does not check the strides in the "merged" case!

#[test]

#[allow(clippy::cognitive_complexity)]

fn merge_axes() {

macro_rules! assert_merged {

($arr:expr, $slice:expr, $take:expr, $into:expr) => {

let mut v = $arr.slice($slice);

let merged_len = v.len_of(Axis($take)) * v.len_of(Axis($into));

assert!(v.merge_axes(Axis($take), Axis($into)));

assert_eq!(v.len_of(Axis($take)), if merged_len == 0 { 0 } else { 1 });

assert_eq!(v.len_of(Axis($into)), merged_len);

};

}

macro_rules! assert_not_merged {

($arr:expr, $slice:expr, $take:expr, $into:expr) => {

let mut v = $arr.slice($slice);

let old_dim = v.raw_dim();

let old_strides = v.strides().to_owned();

assert!(!v.merge_axes(Axis($take), Axis($into)));

assert_eq!(v.raw_dim(), old_dim);

assert_eq!(v.strides(), &old_strides[..]);

};

}

let a = Array4::<u8>::zeros((3, 4, 5, 4));

assert_not_merged!(a, s![.., .., .., ..], 0, 0);

assert_merged!(a, s![.., .., .., ..], 0, 1);

assert_not_merged!(a, s![.., .., .., ..], 0, 2);

assert_not_merged!(a, s![.., .., .., ..], 0, 3);

assert_not_merged!(a, s![.., .., .., ..], 1, 0);

assert_not_merged!(a, s![.., .., .., ..], 1, 1);

assert_merged!(a, s![.., .., .., ..], 1, 2);

assert_not_merged!(a, s![.., .., .., ..], 1, 3);

assert_not_merged!(a, s![.., .., .., ..], 2, 1);

assert_not_merged!(a, s![.., .., .., ..], 2, 2);

assert_merged!(a, s![.., .., .., ..], 2, 3);

assert_not_merged!(a, s![.., .., .., ..], 3, 0);

assert_not_merged!(a, s![.., .., .., ..], 3, 1);

assert_not_merged!(a, s![.., .., .., ..], 3, 2);

assert_not_merged!(a, s![.., .., .., ..], 3, 3);

assert_merged!(a, s![.., .., .., ..;2], 0, 1);

assert_not_merged!(a, s![.., .., .., ..;2], 1, 0);

assert_merged!(a, s![.., .., .., ..;2], 1, 2);

assert_not_merged!(a, s![.., .., .., ..;2], 2, 1);

assert_merged!(a, s![.., .., .., ..;2], 2, 3);

assert_not_merged!(a, s![.., .., .., ..;2], 3, 2);

assert_merged!(a, s![.., .., .., ..3], 0, 1);

assert_not_merged!(a, s![.., .., .., ..3], 1, 0);

assert_merged!(a, s![.., .., .., ..3], 1, 2);

assert_not_merged!(a, s![.., .., .., ..3], 2, 1);

assert_not_merged!(a, s![.., .., .., ..3], 2, 3);

assert_merged!(a, s![.., .., ..;2, ..], 0, 1);

assert_not_merged!(a, s![.., .., ..;2, ..], 1, 0);

assert_not_merged!(a, s![.., .., ..;2, ..], 1, 2);

assert_not_merged!(a, s![.., .., ..;2, ..], 2, 3);

assert_merged!(a, s![.., ..;2, .., ..], 0, 1);

assert_not_merged!(a, s![.., ..;2, .., ..], 1, 0);

assert_not_merged!(a, s![.., ..;2, .., ..], 1, 2);

assert_merged!(a, s![.., ..;2, .., ..], 2, 3);

assert_not_merged!(a, s![.., ..;2, .., ..], 3, 2);

let a = Array4::<u8>::zeros((3, 1, 5, 1).f());

assert_merged!(a, s![.., .., ..;2, ..], 0, 1);

assert_merged!(a, s![.., .., ..;2, ..], 0, 3);

assert_merged!(a, s![.., .., ..;2, ..], 1, 0);

assert_merged!(a, s![.., .., ..;2, ..], 1, 1);

assert_merged!(a, s![.., .., ..;2, ..], 1, 2);

assert_merged!(a, s![.., .., ..;2, ..], 1, 3);

assert_merged!(a, s![.., .., ..;2, ..], 2, 1);

assert_merged!(a, s![.., .., ..;2, ..], 2, 3);

assert_merged!(a, s![.., .., ..;2, ..], 3, 0);

assert_merged!(a, s![.., .., ..;2, ..], 3, 1);

assert_merged!(a, s![.., .., ..;2, ..], 3, 2);

assert_merged!(a, s![.., .., ..;2, ..], 3, 3);

let a = Array4::<u8>::zeros((3, 0, 5, 1));

assert_merged!(a, s![.., .., ..;2, ..], 0, 1);

assert_merged!(a, s![.., .., ..;2, ..], 1, 1);

assert_merged!(a, s![.., .., ..;2, ..], 2, 1);

assert_merged!(a, s![.., .., ..;2, ..], 3, 1);

assert_merged!(a, s![.., .., ..;2, ..], 1, 0);

assert_merged!(a, s![.., .., ..;2, ..], 1, 2);

assert_merged!(a, s![.., .., ..;2, ..], 1, 3);

}

#[test]

fn swapaxes() {

let mut a = arr2(&[[1., 2.], [3., 4.0f32]]);

let b = arr2(&[[1., 3.], [2., 4.0f32]]);

assert!(a != b);

a.swap_axes(0, 1);

assert_eq!(a, b);

a.swap_axes(1, 1);

assert_eq!(a, b);

assert_eq!(a.as_slice_memory_order(), Some(&[1., 2., 3., 4.][..]));

assert_eq!(b.as_slice_memory_order(), Some(&[1., 3., 2., 4.][..]));

}

#[test]

fn permuted_axes() {

let a = array![1].index_axis_move(Axis(0), 0);

let permuted = a.view().permuted_axes([]);

assert_eq!(a, permuted);

let a = array![1];

let permuted = a.view().permuted_axes([0]);

assert_eq!(a, permuted);

let a = Array::from_iter(0..24)

.into_shape_with_order((2, 3, 4))

.unwrap();

let permuted = a.view().permuted_axes([2, 1, 0]);

for ((i0, i1, i2), elem) in a.indexed_iter() {

assert_eq!(*elem, permuted[(i2, i1, i0)]);

}

let permuted = a.view().into_dyn().permuted_axes(&[0, 2, 1][..]);

for ((i0, i1, i2), elem) in a.indexed_iter() {

assert_eq!(*elem, permuted[&[i0, i2, i1][..]]);

}

let a = Array::from_iter(0..120)

.into_shape_with_order((2, 3, 4, 5))

.unwrap();

let permuted = a.view().permuted_axes([1, 0, 3, 2]);

for ((i0, i1, i2, i3), elem) in a.indexed_iter() {

assert_eq!(*elem, permuted[(i1, i0, i3, i2)]);

}

let permuted = a.view().into_dyn().permuted_axes(&[1, 2, 3, 0][..]);

for ((i0, i1, i2, i3), elem) in a.indexed_iter() {

assert_eq!(*elem, permuted[&[i1, i2, i3, i0][..]]);

}

}

#[should_panic]

#[test]

fn permuted_axes_repeated_axis() {

let a = Array::from_iter(0..24)

.into_shape_with_order((2, 3, 4))

.unwrap();

a.view().permuted_axes([1, 0, 1]);

}

#[should_panic]

#[test]

fn permuted_axes_missing_axis() {

let a = Array::from_iter(0..24)

.into_shape_with_order((2, 3, 4))

.unwrap()

.into_dyn();

a.view().permuted_axes(&[2, 0][..]);

}

#[should_panic]

#[test]

fn permuted_axes_oob() {

let a = Array::from_iter(0..24)

.into_shape_with_order((2, 3, 4))

.unwrap();

a.view().permuted_axes([1, 0, 3]);

}

#[test]

fn standard_layout() {

let mut a = arr2(&[[1., 2.], [3., 4.0]]);

assert!(a.is_standard_layout());

a.swap_axes(0, 1);

assert!(!a.is_standard_layout());

a.swap_axes(0, 1);

assert!(a.is_standard_layout());

let x1 = a.index_axis(Axis(0), 0);

assert!(x1.is_standard_layout());

let x2 = a.index_axis(Axis(1), 0);

assert!(!x2.is_standard_layout());

let x3 = ArrayView1::from_shape(1.strides(2), &[1]).unwrap();

assert!(x3.is_standard_layout());

let x4 = ArrayView2::from_shape((0, 2).strides((0, 1)), &[1, 2]).unwrap();

assert!(x4.is_standard_layout());

}

#[test]

fn iter_size_hint() {

let mut a = arr2(&[[1., 2.], [3., 4.]]);

{

let mut it = a.iter();

assert_eq!(it.size_hint(), (4, Some(4)));

it.next();

assert_eq!(it.size_hint().0, 3);

it.next();

assert_eq!(it.size_hint().0, 2);

it.next();

assert_eq!(it.size_hint().0, 1);

it.next();

assert_eq!(it.size_hint().0, 0);

assert!(it.next().is_none());

assert_eq!(it.size_hint().0, 0);

}

a.swap_axes(0, 1);

{

let mut it = a.iter();

assert_eq!(it.size_hint(), (4, Some(4)));

it.next();

assert_eq!(it.size_hint().0, 3);

it.next();

assert_eq!(it.size_hint().0, 2);

it.next();

assert_eq!(it.size_hint().0, 1);

it.next();

assert_eq!(it.size_hint().0, 0);

assert!(it.next().is_none());

assert_eq!(it.size_hint().0, 0);

}

}

#[test]

fn zero_axes() {

let mut a = arr1::<f32>(&[]);

if a.iter().next().is_some() {

panic!();

}

a.map(|_| panic!());

a.map_inplace(|_| panic!());

a.for_each(|_| panic!());

println!("{:?}", a);

let b = arr2::<f32, 0>(&[[], [], [], []]);

println!("{:?}\n{:?}", b.shape(), b);

// we can even get a subarray of b

let bsub = b.index_axis(Axis(0), 2);

assert_eq!(bsub.dim(), 0);

}

#[test]

fn equality() {

let a = arr2(&[[1., 2.], [3., 4.]]);

let mut b = arr2(&[[1., 2.], [2., 4.]]);

assert!(a != b);

b[(1, 0)] = 3.;

assert!(a == b);

// make sure we can compare different shapes without failure.

let c = arr2(&[[1., 2.]]);

assert!(a != c);

}

#[test]

fn map1() {

let a = arr2(&[[1., 2.], [3., 4.]]);

let b = a.map(|&x| (x / 3.) as isize);

assert_eq!(b, arr2(&[[0, 0], [1, 1]]));

// test map to reference with array's lifetime.

let c = a.map(|x| x);

assert_eq!(a[(0, 0)], *c[(0, 0)]);

}

#[test]

fn mapv_into_any_same_type() {