ndarray 0.12.1

#![allow(non_snake_case)]

#[macro_use]
extern crate ndarray;
#[macro_use]
extern crate defmac;
extern crate itertools;

use ndarray::{Slice, SliceInfo, SliceOrIndex};
use ndarray::prelude::*;
use ndarray::{
    rcarr2,
    arr3,
};
use ndarray::indices;
use itertools::{enumerate, zip};

#[test]
fn test_matmul_rcarray()
{
    let mut A = RcArray::<usize, _>::zeros((2, 3));
    for (i, elt) in A.iter_mut().enumerate() {
        *elt = i;
    }

    let mut B = RcArray::<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 = RcArray::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 = RcArray::linspace(0., ((n * m) - 1) as f32, n as usize * m as usize ).reshape((n, m));
    let b = RcArray::eye(m);
    assert_eq!(a.dot(&b), a);
    let c = RcArray::eye(n);
    assert_eq!(c.dot(&a), a);
}


#[deny(unsafe_code)]
#[test]
fn test_slice()
{
    let mut A = RcArray::<usize, _>::zeros((3, 4, 5));
    for (i, elt) in A.iter_mut().enumerate() {
        *elt = i;
    }

    let vi = A.slice(s![1.., ..;2, Slice::new(0, None, 2)]);
    assert_eq!(vi.shape(), &[2, 2, 3]);
    let vi = A.slice(s![.., .., ..]);
    assert_eq!(vi.shape(), A.shape());
    assert!(vi.iter().zip(A.iter()).all(|(a, b)| a == b));
}

#[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 = RcArray::<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, .., ..;2, ..1, ..1, 1.., ..]);
    let new_shape = &[2, 1, 2, 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(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, ..;2];
    arr.slice(info);
    arr.slice_mut(info);
    arr.view().slice_move(info);
    arr.view().slice_collapse(info);
}

#[test]
fn test_slice_dyninput_array_fixed() {
    let mut arr = Array3::<f64>::zeros((5, 2, 5)).into_dyn();
    let info = s![1.., 1, ..;2];
    arr.slice(info);
    arr.slice_mut(info);
    arr.view().slice_move(info);
    arr.view().slice_collapse(info.as_ref());
}

#[test]
fn test_slice_array_dyn() {
    let mut arr = Array3::<f64>::zeros((5, 2, 5));
    let info = &SliceInfo::<_, IxDyn>::new([
        SliceOrIndex::from(1..),
        SliceOrIndex::from(1),
        SliceOrIndex::from(..).step_by(2),
    ]).unwrap();
    arr.slice(info);
    arr.slice_mut(info);
    arr.view().slice_move(info);
    arr.view().slice_collapse(info);
}

#[test]
fn test_slice_dyninput_array_dyn() {
    let mut arr = Array3::<f64>::zeros((5, 2, 5)).into_dyn();
    let info = &SliceInfo::<_, IxDyn>::new([
        SliceOrIndex::from(1..),
        SliceOrIndex::from(1),
        SliceOrIndex::from(..).step_by(2),
    ]).unwrap();
    arr.slice(info);
    arr.slice_mut(info);
    arr.view().slice_move(info);
    arr.view().slice_collapse(info.as_ref());
}

#[test]
fn test_slice_dyninput_vec_fixed() {
    let mut arr = Array3::<f64>::zeros((5, 2, 5)).into_dyn();
    let info = &SliceInfo::<_, Ix2>::new(vec![
        SliceOrIndex::from(1..),
        SliceOrIndex::from(1),
        SliceOrIndex::from(..).step_by(2),
    ]).unwrap();
    arr.slice(info.as_ref());
    arr.slice_mut(info.as_ref());
    arr.view().slice_move(info.as_ref());
    arr.view().slice_collapse(info.as_ref());
}

#[test]
fn test_slice_dyninput_vec_dyn() {
    let mut arr = Array3::<f64>::zeros((5, 2, 5)).into_dyn();
    let info = &SliceInfo::<_, IxDyn>::new(vec![
        SliceOrIndex::from(1..),
        SliceOrIndex::from(1),
        SliceOrIndex::from(..).step_by(2),
    ]).unwrap();
    arr.slice(info.as_ref());
    arr.slice_mut(info.as_ref());
    arr.view().slice_move(info.as_ref());
    arr.view().slice_collapse(info.as_ref());
}

#[test]
fn test_slice_with_subview() {
    let mut arr = RcArray::<usize, _>::zeros((3, 5, 4));
    for (i, elt) in arr.iter_mut().enumerate() {
        *elt = i;
    }

    let vi = arr.slice(s![1.., 2, ..;2]);
    assert_eq!(vi.shape(), &[2, 2]);
    assert!(
        vi.iter()
            .zip(arr.index_axis(Axis(1), 2).slice(s![1.., ..;2]).iter())
            .all(|(a, b)| a == b)
    );

    let vi = arr.slice(s![1, 2, ..;2]);
    assert_eq!(vi.shape(), &[2]);
    assert!(
        vi.iter()
            .zip(
                arr.index_axis(Axis(0), 1)
                    .index_axis(Axis(0), 2)
                    .slice(s![..;2])
                    .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 = RcArray::<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 RcArray 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));
}

#[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 = RcArray::<i32, _>::zeros((3, 4));
    let _vi = a.slice(s![..10, ..]);
}

#[should_panic]
#[test]
fn slice_axis_oob() {
    let a = RcArray::<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 = RcArray::<i32, _>::zeros(vec![3, 4, 5]);
    let _vi = a.slice(s![.., ..]);
}

#[test]
fn test_index()
{
    let mut A = RcArray::<usize, _>::zeros((2, 3));
    for (i, elt) in A.iter_mut().enumerate() {
        *elt = i;
    }

    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();
    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((3, 4)).unwrap();
    assert_eq!(a[1], v[[0, 1]]);
    let w = v.into_shape((2, 2, 3)).unwrap();
    assert_eq!(a[1], w[[0, 0, 1]]);
}

#[test]
fn test_add()
{
    let mut A = RcArray::<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 = RcArray::zeros(2*3*4*5*6).reshape((2,3,4,5,6));
    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_rcarray()
{
    let mut mat = RcArray::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.clone().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 = RcArray::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.reshape(4);
    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 = RcArray::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.reshape(6);
    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 = RcArray::linspace(0., 15., 16).reshape((2, 4, 2));
    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 = RcArray::linspace(8., 15., 8).reshape((4,2));
    assert_eq!(n, s2);
    let m = RcArray::from_vec(vec![2., 3., 10., 11.]).reshape((2, 2));
    assert_eq!(m, mat.index_axis(Axis(1), 1));
}

#[should_panic]
#[test]
fn test_sub_oob_1() {
    let mat = RcArray::linspace(0., 15., 16).reshape((2, 4, 2));
    mat.index_axis(Axis(0), 2);
}


#[test]
fn test_select(){
    // 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!(r.all_close(&r_target,1e-8));
    assert!(c.all_close(&c_target.t(),1e-8));

    // 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!(r.all_close(&r_target,1e-8));
    assert!(c.all_close(&c_target,1e-8));

}


#[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, _>(&[[]]).into_diag();
    assert_eq!(d.dim(), 0);
    let d = RcArray::<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]
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((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((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((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((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((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 assign()
{
    let mut a = arr2(&[[1., 2.], [3., 4.]]);
    let     b = arr2(&[[1., 3.], [2., 4.]]);
    a.assign(&b);
    assert_eq!(a, b);

    /* Test broadcasting */
    a.assign(&RcArray::zeros(1));
    assert_eq!(a, RcArray::zeros((2, 2)));

    /* Test other type */
    a.assign(&Array::from_elem((2, 2), 3.));
    assert_eq!(a, RcArray::from_elem((2, 2), 3.));

    /* Test mut view */
    let mut a = arr2(&[[1, 2], [3, 4]]);
    {
        let mut v = a.view_mut();
        v.slice_collapse(s![..1, ..]);
        v.fill(0);
    }
    assert_eq!(a, arr2(&[[0, 0], [3, 4]]));
}

#[test]
fn sum_mean()
{
    let a = arr2(&[[1., 2.], [3., 4.]]);
    assert_eq!(a.sum_axis(Axis(0)), arr1(&[4., 6.]));
    assert_eq!(a.sum_axis(Axis(1)), arr1(&[3., 7.]));
    assert_eq!(a.mean_axis(Axis(0)), arr1(&[2., 3.]));
    assert_eq!(a.mean_axis(Axis(1)), arr1(&[1.5, 3.5]));
    assert_eq!(a.sum_axis(Axis(1)).sum_axis(Axis(0)), arr0(10.));
    assert_eq!(a.view().mean_axis(Axis(1)), aview1(&[1.5, 3.5]));
    assert_eq!(a.sum(), 10.);
}

#[test]
fn sum_mean_empty() {
    assert_eq!(Array3::<f32>::ones((2, 0, 3)).sum(), 0.);
    assert_eq!(Array1::<f32>::ones(0).sum_axis(Axis(0)), arr0(0.));
    assert_eq!(
        Array3::<f32>::ones((2, 0, 3)).sum_axis(Axis(1)),
        Array::zeros((2, 3)),
    );
    let a = Array1::<f32>::ones(0).mean_axis(Axis(0));
    assert_eq!(a.shape(), &[]);
    assert!(a[()].is_nan());
    let a = Array3::<f32>::ones((2, 0, 3)).mean_axis(Axis(1));
    assert_eq!(a.shape(), &[2, 3]);
    a.mapv(|x| assert!(x.is_nan()));
}

#[test]
fn var_axis() {
    let a = array![
        [
            [-9.76, -0.38, 1.59, 6.23],
            [-8.57, -9.27, 5.76, 6.01],
            [-9.54, 5.09, 3.21, 6.56],
        ],
        [
            [ 8.23, -9.63, 3.76, -3.48],
            [-5.46, 5.86, -2.81, 1.35],
            [-1.08, 4.66, 8.34, -0.73],
        ],
    ];
    assert!(a.var_axis(Axis(0), 1.5).all_close(
        &aview2(&[
            [3.236401e+02, 8.556250e+01, 4.708900e+00, 9.428410e+01],
            [9.672100e+00, 2.289169e+02, 7.344490e+01, 2.171560e+01],
            [7.157160e+01, 1.849000e-01, 2.631690e+01, 5.314410e+01]
        ]),
        1e-4,
    ));
    assert!(a.var_axis(Axis(1), 1.7).all_close(
        &aview2(&[
            [0.61676923, 80.81092308, 6.79892308, 0.11789744],
            [75.19912821, 114.25235897, 48.32405128, 9.03020513],
        ]),
        1e-8,
    ));
    assert!(a.var_axis(Axis(2), 2.3).all_close(
        &aview2(&[
            [ 79.64552941, 129.09663235, 95.98929412],
            [109.64952941, 43.28758824, 36.27439706],
        ]),
        1e-8,
    ));

    let b = array![[1.1, 2.3, 4.7]];
    assert!(b.var_axis(Axis(0), 0.).all_close(&aview1(&[0., 0., 0.]), 1e-12));
    assert!(b.var_axis(Axis(1), 0.).all_close(&aview1(&[2.24]), 1e-12));

    let c = array![[], []];
    assert_eq!(c.var_axis(Axis(0), 0.), aview1(&[]));

    let d = array![1.1, 2.7, 3.5, 4.9];
    assert!(d.var_axis(Axis(0), 0.).all_close(&aview0(&1.8875), 1e-12));
}

#[test]
fn std_axis() {
    let a = array![
       [
            [ 0.22935481,  0.08030619,  0.60827517,  0.73684379],
            [ 0.90339851,  0.82859436,  0.64020362,  0.2774583 ],
            [ 0.44485313,  0.63316367,  0.11005111,  0.08656246]
       ],
       [
           [ 0.28924665,  0.44082454,  0.59837736,  0.41014531],
            [ 0.08382316,  0.43259439,  0.1428889 ,  0.44830176],
            [ 0.51529756,  0.70111616,  0.20799415,  0.91851457]
       ],
    ];
    assert!(a.std_axis(Axis(0), 1.5).all_close(
        &aview2(&[
            [ 0.05989184,  0.36051836,  0.00989781,  0.32669847],
            [ 0.81957535,  0.39599997,  0.49731472,  0.17084346],
            [ 0.07044443,  0.06795249,  0.09794304,  0.83195211],
        ]),
        1e-4,
    ));
    assert!(a.std_axis(Axis(1), 1.7).all_close(
        &aview2(&[
            [ 0.42698655,  0.48139215,  0.36874991,  0.41458724],
            [ 0.26769097,  0.18941435,  0.30555015,  0.35118674],
        ]),
        1e-8,
    ));
    assert!(a.std_axis(Axis(2), 2.3).all_close(
        &aview2(&[
            [ 0.41117907,  0.37130425,  0.35332388],
            [ 0.16905862,  0.25304841,  0.39978276],
        ]),
        1e-8,
    ));

    let b = array![[100000., 1., 0.01]];
    assert!(b.std_axis(Axis(0), 0.).all_close(&aview1(&[0., 0., 0.]), 1e-12));
    assert!(
        b.std_axis(Axis(1), 0.).all_close(&aview1(&[47140.214021552769]), 1e-6),
    );

    let c = array![[], []];
    assert_eq!(c.std_axis(Axis(0), 0.), aview1(&[]));
}

#[test]
#[should_panic]
fn var_axis_bad_dof() {
    let a = array![1., 2., 3.];
    a.var_axis(Axis(0), 4.);
}

#[test]
#[should_panic]
fn var_axis_empty_axis() {
    let a = array![[], []];
    a.var_axis(Axis(1), 0.);
}

#[test]
#[should_panic]
fn std_axis_bad_dof() {
    let a = array![1., 2., 3.];
    a.std_axis(Axis(0), 4.);
}

#[test]
#[should_panic]
fn std_axis_empty_axis() {
    let a = array![[], []];
    a.std_axis(Axis(1), 0.);
}

#[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>(&[]);
    for _ in a.iter() {
        assert!(false);
    }
    a.map(|_| assert!(false));
    a.map_inplace(|_| assert!(false));
    a.visit(|_| assert!(false));
    println!("{:?}", a);
    let b = arr2::<f32, _>(&[[], [], [], []]);
    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 as_slice_memory_order()
{
    // test that mutation breaks sharing
    let a = rcarr2(&[[1., 2.], [3., 4.0f32]]);
    let mut b = a.clone();
    for elt in b.as_slice_memory_order_mut().unwrap() {
        *elt = 0.;
    }
    assert!(a != b, "{:?} != {:?}", a, b);
}

#[test]
fn array0_into_scalar() {
    // With this kind of setup, the `Array`'s pointer is not the same as the
    // underlying `Vec`'s pointer.
    let a: Array0<i32> = array![4, 5, 6, 7].index_axis_move(Axis(0), 2);
    assert_ne!(a.as_ptr(), a.into_raw_vec().as_ptr());
    // `.into_scalar()` should still work correctly.
    let a: Array0<i32> = array![4, 5, 6, 7].index_axis_move(Axis(0), 2);
    assert_eq!(a.into_scalar(), 6);

    // It should work for zero-size elements too.
    let a: Array0<()> = array![(), (), (), ()].index_axis_move(Axis(0), 2);
    assert_eq!(a.into_scalar(), ());
}

#[test]
fn owned_array1() {
    let mut a = Array::from_vec(vec![1, 2, 3, 4]);
    for elt in a.iter_mut() {
        *elt = 2;
    }
    for elt in a.iter() {
        assert_eq!(*elt, 2);
    }
    assert_eq!(a.shape(), &[4]);

    let mut a = Array::zeros((2, 2));
    let mut b = RcArray::zeros((2, 2));
    a[(1, 1)] = 3;
    b[(1, 1)] = 3;
    assert_eq!(a, b);

    let c = a.clone();

    let d1 = &a + &b;
    let d2 = a + b;
    assert!(c != d1);
    assert_eq!(d1, d2);
}

#[test]
fn owned_array_with_stride() {
    let v: Vec<_> = (0..12).collect();
    let dim = (2, 3, 2);
    let strides = (1, 4, 2);

    let a = Array::from_shape_vec(dim.strides(strides), v).unwrap();
    assert_eq!(a.strides(), &[1, 4, 2]);
}

#[test]
fn owned_array_discontiguous() {
    use ::std::iter::repeat;
    let v: Vec<_> = (0..12).flat_map(|x| repeat(x).take(2)).collect();
    let dim = (3, 2, 2);
    let strides = (8, 4, 2);

    let a = Array::from_shape_vec(dim.strides(strides), v).unwrap();
    assert_eq!(a.strides(), &[8, 4, 2]);
    println!("{:?}", a.iter().cloned().collect::<Vec<_>>());
    itertools::assert_equal(a.iter().cloned(), 0..12);
}

#[test]
fn owned_array_discontiguous_drop() {
    use ::std::rc::Rc;
    use ::std::cell::RefCell;
    use ::std::collections::BTreeSet;

    struct InsertOnDrop<T: Ord>(Rc<RefCell<BTreeSet<T>>>, Option<T>);
    impl<T: Ord> Drop for InsertOnDrop<T> {
        fn drop(&mut self) {
            let InsertOnDrop(ref set, ref mut value) = *self;
            set.borrow_mut().insert(value.take().expect("double drop!"));
        }
    }

    let set = Rc::new(RefCell::new(BTreeSet::new()));
    {
        let v: Vec<_> = (0..12).map(|x| InsertOnDrop(set.clone(), Some(x))).collect();
        let mut a = Array::from_shape_vec((2, 6), v).unwrap();
        // discontiguous and non-zero offset
        a.slice_collapse(s![.., 1..]);
    }
    // each item was dropped exactly once
    itertools::assert_equal(set.borrow().iter().cloned(), 0..12);
}

macro_rules! assert_matches {
    ($value:expr, $pat:pat) => {
        match $value {
            $pat => {}
            ref err => panic!("assertion failed: `{}` matches `{}` found: {:?}",
                               stringify!($value), stringify!($pat), err),
        }
    }
}

#[test]
fn from_vec_dim_stride_empty_1d() {
    let empty: [f32; 0] = [];
    assert_matches!(Array::from_shape_vec(0.strides(1), empty.to_vec()),
                    Ok(_));
}

#[test]
fn from_vec_dim_stride_0d() {
    let empty: [f32; 0] = [];
    let one = [1.];
    let two = [1., 2.];
    // too few elements
    assert_matches!(Array::from_shape_vec(().strides(()), empty.to_vec()), Err(_));
    // exact number of elements
    assert_matches!(Array::from_shape_vec(().strides(()), one.to_vec()), Ok(_));
    // too many are ok
    assert_matches!(Array::from_shape_vec(().strides(()), two.to_vec()), Ok(_));
}

#[test]
fn from_vec_dim_stride_2d_1() {
    let two = [1., 2.];
    let d = Ix2(2, 1);
    let s = d.default_strides();
    assert_matches!(Array::from_shape_vec(d.strides(s), two.to_vec()), Ok(_));
}

#[test]
fn from_vec_dim_stride_2d_2() {
    let two = [1., 2.];
    let d = Ix2(1, 2);
    let s = d.default_strides();
    assert_matches!(Array::from_shape_vec(d.strides(s), two.to_vec()), Ok(_));
}

#[test]
fn from_vec_dim_stride_2d_3() {
    let a = arr3(&[[[1]],
                   [[2]],
                   [[3]]]);
    let d = a.raw_dim();
    let s = d.default_strides();
    assert_matches!(Array::from_shape_vec(d.strides(s), a.as_slice().unwrap().to_vec()), Ok(_));
}

#[test]
fn from_vec_dim_stride_2d_4() {
    let a = arr3(&[[[1]],
                   [[2]],
                   [[3]]]);
    let d = a.raw_dim();
    let s = d.fortran_strides();
    assert_matches!(Array::from_shape_vec(d.strides(s), a.as_slice().unwrap().to_vec()), Ok(_));
}

#[test]
fn from_vec_dim_stride_2d_5() {
    let a = arr3(&[[[1, 2, 3]]]);
    let d = a.raw_dim();
    let s = d.fortran_strides();
    assert_matches!(Array::from_shape_vec(d.strides(s), a.as_slice().unwrap().to_vec()), Ok(_));
}

#[test]
fn from_vec_dim_stride_2d_6() {
    let a = [1., 2., 3., 4., 5., 6.];
    let d = (2, 1, 1);
    let s = (2, 2, 1);
    assert_matches!(Array::from_shape_vec(d.strides(s), a.to_vec()), Ok(_));

    let d = (1, 2, 1);
    let s = (2, 2, 1);
    assert_matches!(Array::from_shape_vec(d.strides(s), a.to_vec()), Ok(_));
}

#[test]
fn from_vec_dim_stride_2d_7() {
    // empty arrays can have 0 strides
    let a: [f32; 0] = [];
    // [[]] shape=[4, 0], strides=[0, 1]
    let d = (4, 0);
    let s = (0, 1);
    assert_matches!(Array::from_shape_vec(d.strides(s), a.to_vec()), Ok(_));
}

#[test]
fn from_vec_dim_stride_2d_8() {
    // strides of length 1 axes can be zero
    let a = [1.];
    let d = (1, 1);
    let s = (0, 1);
    assert_matches!(Array::from_shape_vec(d.strides(s), a.to_vec()), Ok(_));
}

#[test]
fn from_vec_dim_stride_2d_rejects() {
    let two = [1., 2.];
    let d = (2, 2);
    let s = (1, 0);
    assert_matches!(Array::from_shape_vec(d.strides(s), two.to_vec()), Err(_));

    let d = (2, 2);
    let s = (0, 1);
    assert_matches!(Array::from_shape_vec(d.strides(s), two.to_vec()), Err(_));
}

#[test]
fn views() {
    let a = RcArray::from_vec(vec![1, 2, 3, 4]).reshape((2, 2));
    let b = a.view();
    assert_eq!(a, b);
    assert_eq!(a.shape(), b.shape());
    assert_eq!(a.clone() + a.clone(), &b + &b);
    assert_eq!(a.clone() + b, &b + &b);
    a.clone()[(0, 0)] = 99;
    assert_eq!(b[(0, 0)], 1);

    assert_eq!(a.view().into_iter().cloned().collect::<Vec<_>>(),
               vec![1, 2, 3, 4]);
}

#[test]
fn view_mut() {
    let mut a = RcArray::from_vec(vec![1, 2, 3, 4]).reshape((2, 2));
    for elt in &mut a.view_mut() {
        *elt = 0;
    }
    assert_eq!(a, Array::zeros((2, 2)));
    {
        let mut b = a.view_mut();
        b[(0, 0)] = 7;
    }
    assert_eq!(a[(0, 0)], 7);

    for elt in a.view_mut() {
        *elt = 2;
    }
    assert_eq!(a, RcArray::from_elem((2, 2), 2));
}

#[test]
fn slice_mut() {
    let mut a = RcArray::from_vec(vec![1, 2, 3, 4]).reshape((2, 2));
    for elt in a.slice_mut(s![.., ..]) {
        *elt = 0;
    }
    assert_eq!(a, aview2(&[[0, 0], [0, 0]]));

    let mut b = arr2(&[[1, 2, 3],
                       [4, 5, 6]]);
    let c = b.clone(); // make sure we can mutate b even if it has to be unshared first
    for elt in b.slice_mut(s![.., ..1]) {
        *elt = 0;
    }
    assert_eq!(b, aview2(&[[0, 2, 3],
                           [0, 5, 6]]));
    assert!(c != b);

    for elt in b.slice_mut(s![.., ..;2]) {
        *elt = 99;
    }
    assert_eq!(b, aview2(&[[99, 2, 99],
                           [99, 5, 99]]));
}

#[test]
fn assign_ops()
{
    let mut a = arr2(&[[1., 2.], [3., 4.]]);
    let     b = arr2(&[[1., 3.], [2., 4.]]);
    (*&mut a.view_mut()) += &b;
    assert_eq!(a, arr2(&[[2., 5.], [5., 8.]]));

    a -= &b;
    a -= &b;
    assert_eq!(a, arr2(&[[0., -1.,], [1., 0.]]));

    a += 1.;
    assert_eq!(a, arr2(&[[1., 0.,], [2., 1.]]));
    a *= 10.;
    a /= 5.;
    assert_eq!(a, arr2(&[[2., 0.,], [4., 2.]]));
}

#[test]
fn aview() {
    let a = arr2(&[[1., 2., 3.], [4., 5., 6.]]);
    let data = [[1., 2., 3.], [4., 5., 6.]];
    let b = aview2(&data);
    assert_eq!(a, b);
    assert_eq!(b.shape(), &[2, 3]);
}

#[test]
fn aview_mut() {
    let mut data = [0; 16];
    {
        let mut a = aview_mut1(&mut data).into_shape((4, 4)).unwrap();
        {
            let mut slc = a.slice_mut(s![..2, ..;2]);
            slc += 1;
        }
    }
    assert_eq!(data, [1, 0, 1, 0,  1, 0, 1, 0,  0, 0, 0, 0,  0, 0, 0, 0]);
}

#[test]
fn transpose_view() {
    let a = arr2(&[[1, 2],
                   [3, 4]]);
    let at = a.view().reversed_axes();
    assert_eq!(at, arr2(&[[1, 3], [2, 4]]));

    let a = arr2(&[[1, 2, 3],
                   [4, 5, 6]]);
    let at = a.view().reversed_axes();
    assert_eq!(at, arr2(&[[1, 4], [2, 5], [3, 6]]));
}

#[test]
fn transpose_view_mut() {
    let mut a = arr2(&[[1, 2],
                       [3, 4]]);
    let mut at = a.view_mut().reversed_axes();
    at[[0, 1]] = 5;
    assert_eq!(at, arr2(&[[1, 5], [2, 4]]));

    let mut a = arr2(&[[1, 2, 3],
                       [4, 5, 6]]);
    let mut at = a.view_mut().reversed_axes();
    at[[2, 1]] = 7;
    assert_eq!(at, arr2(&[[1, 4], [2, 5], [3, 7]]));
}

#[test]
fn reshape() {
    let data = [1, 2, 3, 4, 5, 6, 7, 8];
    let v = aview1(&data);
    let u = v.into_shape((3, 3));
    assert!(u.is_err());
    let u = v.into_shape((2, 2, 2));
    assert!(u.is_ok());
    let u = u.unwrap();
    assert_eq!(u.shape(), &[2, 2, 2]);
    let s = u.into_shape((4, 2)).unwrap();
    assert_eq!(s.shape(), &[4, 2]);
    assert_eq!(s, aview2(&[[1, 2],
                           [3, 4],
                           [5, 6],
                           [7, 8]]));
}

#[test]
#[should_panic(expected = "IncompatibleShape")]
fn reshape_error1() {
    let data = [1, 2, 3, 4, 5, 6, 7, 8];
    let v = aview1(&data);
    let _u = v.into_shape((2, 5)).unwrap();
}

#[test]
#[should_panic(expected = "IncompatibleLayout")]
fn reshape_error2() {
    let data = [1, 2, 3, 4, 5, 6, 7, 8];
    let v = aview1(&data);
    let mut u = v.into_shape((2, 2, 2)).unwrap();
    u.swap_axes(0, 1);
    let _s = u.into_shape((2, 4)).unwrap();
}

#[test]
fn reshape_f() {
    let mut u = Array::zeros((3, 4).f());
    for (i, elt) in enumerate(u.as_slice_memory_order_mut().unwrap()) {
        *elt = i as i32;
    }
    let v = u.view();
    println!("{:?}", v);

    // noop ok
    let v2 = v.into_shape((3, 4));
    assert!(v2.is_ok());
    assert_eq!(v, v2.unwrap());

    let u = v.into_shape((3, 2, 2));
    assert!(u.is_ok());
    let u = u.unwrap();
    println!("{:?}", u);
    assert_eq!(u.shape(), &[3, 2, 2]);
    let s = u.into_shape((4, 3)).unwrap();
    println!("{:?}", s);
    assert_eq!(s.shape(), &[4, 3]);
    assert_eq!(s, aview2(&[[0, 4, 8],
                           [1, 5, 9],
                           [2, 6,10],
                           [3, 7,11]]));
}

#[test]
fn insert_axis() {
    defmac!(test_insert orig, index, new => {
        let res = orig.insert_axis(Axis(index));
        assert_eq!(res, new);
        assert!(res.is_standard_layout());
    });

    let v = 1;
    test_insert!(aview0(&v), 0, arr1(&[1]));
    assert!(::std::panic::catch_unwind(|| aview0(&v).insert_axis(Axis(1))).is_err());

    test_insert!(arr1(&[1, 2, 3]), 0, arr2(&[[1, 2, 3]]));
    test_insert!(arr1(&[1, 2, 3]), 1, arr2(&[[1], [2], [3]]));
    assert!(::std::panic::catch_unwind(|| arr1(&[1, 2, 3]).insert_axis(Axis(2))).is_err());

    test_insert!(arr2(&[[1, 2, 3], [4, 5, 6]]), 0, arr3(&[[[1, 2, 3], [4, 5, 6]]]));
    test_insert!(arr2(&[[1, 2, 3], [4, 5, 6]]), 1, arr3(&[[[1, 2, 3]], [[4, 5, 6]]]));
    test_insert!(arr2(&[[1, 2, 3], [4, 5, 6]]), 2, arr3(&[[[1], [2], [3]], [[4], [5], [6]]]));
    assert!(::std::panic::catch_unwind(
        || arr2(&[[1, 2, 3], [4, 5, 6]]).insert_axis(Axis(3))).is_err());

    test_insert!(Array3::<u8>::zeros((3, 4, 5)), 0, Array4::<u8>::zeros((1, 3, 4, 5)));
    test_insert!(Array3::<u8>::zeros((3, 4, 5)), 1, Array4::<u8>::zeros((3, 1, 4, 5)));
    test_insert!(Array3::<u8>::zeros((3, 4, 5)), 3, Array4::<u8>::zeros((3, 4, 5, 1)));
    assert!(::std::panic::catch_unwind(
        || Array3::<u8>::zeros((3, 4, 5)).insert_axis(Axis(4))).is_err());

    test_insert!(Array6::<u8>::zeros((2, 3, 4, 3, 2, 3)), 0,
                 ArrayD::<u8>::zeros(vec![1, 2, 3, 4, 3, 2, 3]));
    test_insert!(Array6::<u8>::zeros((2, 3, 4, 3, 2, 3)), 3,
                 ArrayD::<u8>::zeros(vec![2, 3, 4, 1, 3, 2, 3]));
    test_insert!(Array6::<u8>::zeros((2, 3, 4, 3, 2, 3)), 6,
                 ArrayD::<u8>::zeros(vec![2, 3, 4, 3, 2, 3, 1]));
    assert!(::std::panic::catch_unwind(
        || Array6::<u8>::zeros((2, 3, 4, 3, 2, 3)).insert_axis(Axis(7))).is_err());

    test_insert!(ArrayD::<u8>::zeros(vec![3, 4, 5]), 0, ArrayD::<u8>::zeros(vec![1, 3, 4, 5]));
    test_insert!(ArrayD::<u8>::zeros(vec![3, 4, 5]), 1, ArrayD::<u8>::zeros(vec![3, 1, 4, 5]));
    test_insert!(ArrayD::<u8>::zeros(vec![3, 4, 5]), 3, ArrayD::<u8>::zeros(vec![3, 4, 5, 1]));
    assert!(::std::panic::catch_unwind(
        || ArrayD::<u8>::zeros(vec![3, 4, 5]).insert_axis(Axis(4))).is_err());
}

#[test]
fn insert_axis_f() {
    defmac!(test_insert_f orig, index, new => {
        let res = orig.insert_axis(Axis(index));
        assert_eq!(res, new);
        assert!(res.t().is_standard_layout());
    });

    test_insert_f!(Array0::from_shape_vec(().f(), vec![1]).unwrap(), 0, arr1(&[1]));
    assert!(::std::panic::catch_unwind(
        || Array0::from_shape_vec(().f(), vec![1]).unwrap().insert_axis(Axis(1))).is_err());

    test_insert_f!(Array1::<u8>::zeros((3).f()), 0, Array2::<u8>::zeros((1, 3)));
    test_insert_f!(Array1::<u8>::zeros((3).f()), 1, Array2::<u8>::zeros((3, 1)));
    assert!(::std::panic::catch_unwind(
        || Array1::<u8>::zeros((3).f()).insert_axis(Axis(2))).is_err());

    test_insert_f!(Array3::<u8>::zeros((3, 4, 5).f()), 1, Array4::<u8>::zeros((3, 1, 4, 5)));
    assert!(::std::panic::catch_unwind(
        || Array3::<u8>::zeros((3, 4, 5).f()).insert_axis(Axis(4))).is_err());

    test_insert_f!(ArrayD::<u8>::zeros(vec![3, 4, 5].f()), 1,
                   ArrayD::<u8>::zeros(vec![3, 1, 4, 5]));
    assert!(::std::panic::catch_unwind(
        || ArrayD::<u8>::zeros(vec![3, 4, 5].f()).insert_axis(Axis(4))).is_err());
}

#[test]
fn insert_axis_view() {
    let a = array![[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]];

    assert_eq!(a.index_axis(Axis(1), 0).insert_axis(Axis(0)), array![[[1, 2], [5, 6], [9, 10]]]);
    assert_eq!(a.index_axis(Axis(1), 0).insert_axis(Axis(1)), array![[[1, 2]], [[5, 6]], [[9, 10]]]);
    assert_eq!(a.index_axis(Axis(1), 0).insert_axis(Axis(2)), array![[[1], [2]], [[5], [6]], [[9], [10]]]);
}

#[test]
fn arithmetic_broadcast() {
    let mut a = arr2(&[[1., 2.], [3., 4.]]);
    let b = a.clone() * aview0(&1.);
    assert_eq!(a, b);
    a.swap_axes(0, 1);
    let b = a.clone() / aview0(&1.);
    assert_eq!(a, b);
}

#[test]
fn char_array()
{
    // test compilation & basics of non-numerical array
    let cc = RcArray::from_iter("alphabet".chars()).reshape((4, 2));
    assert!(cc.index_axis(Axis(1), 0) == RcArray::from_iter("apae".chars()));
}

#[test]
fn scalar_ops() {
    let a = Array::<i32, _>::zeros((5, 5));
    let b = &a + 1;
    let c = (&a + &a + 2) - 3;
    println!("{:?}", b);
    println!("{:?}", c);

    let a = Array::<f32, _>::zeros((2, 2));
    let b = (1. + a) * 3.;
    assert_eq!(b, arr2(&[[3., 3.], [3., 3.]]));

    let a = arr1(&[false, true, true]);
    let b = &a ^ true;
    let c = true ^ &a;
    assert_eq!(b, c);
    assert_eq!(true & &a, a);
    assert_eq!(b, arr1(&[true, false, false]));
    assert_eq!(true ^ &a, !a);

    let zero = Array::<f32, _>::zeros((2, 2));
    let one = &zero + 1.;
    assert_eq!(0. * &one, zero);
    assert_eq!(&one * 0., zero);
    assert_eq!((&one + &one).sum(), 8.);
    assert_eq!(&one / 2., 0.5 * &one);
    assert_eq!(&one % 1., zero);

    let zero = Array::<i32, _>::zeros((2, 2));
    let one = &zero + 1;
    assert_eq!(one.clone() << 3, 8 * &one);
    assert_eq!(3 << one.clone() , 6 * &one);

    assert_eq!(&one << 3, 8 * &one);
    assert_eq!(3 << &one , 6 * &one);
}

#[test]
fn split_at() {
    let mut a = arr2(&[[1., 2.], [3., 4.]]);

    {
        let (c0, c1) = a.view().split_at(Axis(1), 1);

        assert_eq!(c0, arr2(&[[1.], [3.]]));
        assert_eq!(c1, arr2(&[[2.], [4.]]));
    }

    {
        let (mut r0, mut r1) = a.view_mut().split_at(Axis(0), 1);
        r0[[0, 1]] = 5.;
        r1[[0, 0]] = 8.;
    }
    assert_eq!(a, arr2(&[[1., 5.], [8., 4.]]));


    let b = RcArray::linspace(0., 59., 60).reshape((3, 4, 5));

    let (left, right) = b.view().split_at(Axis(2), 2);
    assert_eq!(left.shape(), [3, 4, 2]);
    assert_eq!(right.shape(), [3, 4, 3]);
    assert_eq!(left, arr3(&[[[0., 1.], [5., 6.], [10., 11.], [15., 16.]],
                            [[20., 21.], [25., 26.], [30., 31.], [35., 36.]],
                            [[40., 41.], [45., 46.], [50., 51.], [55., 56.]]]));

    // we allow for an empty right view when index == dim[axis]
    let (_, right) = b.view().split_at(Axis(1), 4);
    assert_eq!(right.shape(), [3, 0, 5]);
}

#[test]
#[should_panic]
fn deny_split_at_axis_out_of_bounds() {
    let a = arr2(&[[1., 2.], [3., 4.]]);
    a.view().split_at(Axis(2), 0);
}

#[test]
#[should_panic]
fn deny_split_at_index_out_of_bounds() {
    let a = arr2(&[[1., 2.], [3., 4.]]);
    a.view().split_at(Axis(1), 3);
}

#[test]
fn test_range() {
    let a = Array::range(0., 5., 1.);
    assert_eq!(a.len(), 5);
    assert_eq!(a[0],  0.);
    assert_eq!(a[4],  4.);

    let b = Array::range(0., 2.2, 1.);
    assert_eq!(b.len(), 3);
    assert_eq!(b[0],  0.);
    assert_eq!(b[2],  2.);

    let c = Array::range(0., 5., 2.);
    assert_eq!(c.len(), 3);
    assert_eq!(c[0], 0.);
    assert_eq!(c[1], 2.);
    assert_eq!(c[2], 4.);

    let d = Array::range(1.0, 2.2, 0.1);
    assert_eq!(d.len(), 13);
    assert_eq!(d[0], 1.);
    assert_eq!(d[10], 2.);
    assert_eq!(d[12], 2.2);

    let e = Array::range(1., 1., 1.);
    assert_eq!(e.len(), 0);
    assert!(e.is_empty());
}

#[test]
fn test_f_order() {
    // Test that arrays are logically equal in every way,
    // even if the underlying memory order is different
    let c = arr2(&[[1, 2, 3],
                   [4, 5, 6]]);
    let mut f = Array::zeros(c.dim().f());
    f.assign(&c);
    assert_eq!(f, c);
    assert_eq!(f.shape(), c.shape());
    assert_eq!(c.strides(), &[3, 1]);
    assert_eq!(f.strides(), &[1, 2]);
    itertools::assert_equal(f.iter(), c.iter());
    itertools::assert_equal(f.genrows(), c.genrows());
    itertools::assert_equal(f.outer_iter(), c.outer_iter());
    itertools::assert_equal(f.axis_iter(Axis(0)), c.axis_iter(Axis(0)));
    itertools::assert_equal(f.axis_iter(Axis(1)), c.axis_iter(Axis(1)));

    let dupc = &c + &c;
    let dupf = &f + &f;
    assert_eq!(dupc, dupf);
}

#[test]
fn to_owned_memory_order() {
    // check that .to_owned() makes f-contiguous arrays out of f-contiguous
    // input.
    let c = arr2(&[[1, 2, 3],
                   [4, 5, 6]]);
    let mut f = c.view();
    f.swap_axes(0, 1);
    let fo = f.to_owned();
    assert_eq!(f, fo);
    assert_eq!(f.strides(), fo.strides());
}

#[test]
fn to_owned_neg_stride() {
    let mut c = arr2(&[[1, 2, 3],
                       [4, 5, 6]]);
    c.slice_collapse(s![.., ..;-1]);
    let co = c.to_owned();
    assert_eq!(c, co);
}

#[test]
fn discontiguous_owned_to_owned() {
    let mut c = arr2(&[[1, 2, 3],
                       [4, 5, 6]]);
    c.slice_collapse(s![.., ..;2]);

    let co = c.to_owned();
    assert_eq!(c.strides(), &[3, 2]);
    assert_eq!(co.strides(), &[2, 1]);
    assert_eq!(c, co);
}

#[test]
fn map_memory_order() {
    let a = arr3(&[[[1, 2, 3],
                    [4, 5, 6]],
                   [[7, 8, 9],
                    [0, -1, -2]]]);
    let mut v = a.view();
    v.swap_axes(0, 1);
    let amap = v.map(|x| *x >= 3);
    assert_eq!(amap.dim(), v.dim());
    assert_eq!(amap.strides(), v.strides());
}

#[test]
fn test_contiguous() {
    let c = arr3(&[[[1, 2, 3],
                    [4, 5, 6]],
                   [[4, 5, 6],
                    [7, 7, 7]]]);
    assert!(c.is_standard_layout());
    assert!(c.as_slice_memory_order().is_some());
    let v = c.slice(s![.., 0..1, ..]);
    assert!(!v.is_standard_layout());
    assert!(!v.as_slice_memory_order().is_some());

    let v = c.slice(s![1..2, .., ..]);
    assert!(v.is_standard_layout());
    assert!(v.as_slice_memory_order().is_some());
    let v = v.reversed_axes();
    assert!(!v.is_standard_layout());
    assert!(v.as_slice_memory_order().is_some());
    let mut v = v.reversed_axes();
    v.swap_axes(1, 2);
    assert!(!v.is_standard_layout());
    assert!(v.as_slice_memory_order().is_some());

    let a = Array::<f32, _>::zeros((20, 1));
    let b = Array::<f32, _>::zeros((20, 1).f());
    assert!(a.as_slice().is_some());
    assert!(b.as_slice().is_some());
    assert!(a.as_slice_memory_order().is_some());
    assert!(b.as_slice_memory_order().is_some());
    let a = a.t();
    let b = b.t();
    assert!(a.as_slice().is_some());
    assert!(b.as_slice().is_some());
    assert!(a.as_slice_memory_order().is_some());
    assert!(b.as_slice_memory_order().is_some());
}

#[test]
fn test_all_close() {
    let c = arr3(&[[[1., 2., 3.],
                    [1.5, 1.5, 3.]],
                   [[1., 2., 3.],
                    [1., 2.5, 3.]]]);
    assert!(c.all_close(&aview1(&[1., 2., 3.]), 1.));
    assert!(!c.all_close(&aview1(&[1., 2., 3.]), 0.1));
}

#[test]
fn test_swap() {
    let mut a = arr2(&[[1, 2, 3],
                       [4, 5, 6],
                       [7, 8, 9]]);
    let b = a.clone();

    for i in 0..a.rows() {
        for j in i + 1..a.cols() {
            a.swap((i, j), (j, i));
        }
    }
    assert_eq!(a, b.t());
}

#[test]
fn test_uswap() {
    let mut a = arr2(&[[1, 2, 3],
                       [4, 5, 6],
                       [7, 8, 9]]);
    let b = a.clone();

    for i in 0..a.rows() {
        for j in i + 1..a.cols() {
            unsafe { a.uswap((i, j), (j, i)) };
        }
    }
    assert_eq!(a, b.t());
}

#[test]
fn test_shape() {
    let data = [0, 1, 2, 3, 4, 5];
    let a = Array::from_shape_vec((1, 2, 3), data.to_vec()).unwrap();
    let b = Array::from_shape_vec((1, 2, 3).f(), data.to_vec()).unwrap();
    let c = Array::from_shape_vec((1, 2, 3).strides((1, 3, 1)), data.to_vec()).unwrap();
    println!("{:?}", a);
    println!("{:?}", b);
    println!("{:?}", c);
    assert_eq!(a.strides(), &[6, 3, 1]);
    assert_eq!(b.strides(), &[1, 1, 2]);
    assert_eq!(c.strides(), &[1, 3, 1]);
}

#[test]
fn test_view_from_shape_ptr() {
    let data = [0, 1, 2, 3, 4, 5];
    let view = unsafe { ArrayView::from_shape_ptr((2, 3), data.as_ptr()) };
    assert_eq!(view, aview2(&[[0, 1, 2], [3, 4, 5]]));

    let mut data = data;
    let mut view = unsafe { ArrayViewMut::from_shape_ptr((2, 3), data.as_mut_ptr()) };
    view[[1, 2]] = 6;
    assert_eq!(view, aview2(&[[0, 1, 2], [3, 4, 6]]));
    view[[0, 1]] = 0;
    assert_eq!(view, aview2(&[[0, 0, 2], [3, 4, 6]]));
}

#[test]
fn test_default() {
    let a = <Array<f32, Ix2> as Default>::default();
    assert_eq!(a, aview2(&[[0.0; 0]; 0]));


    #[derive(Default, Debug, PartialEq)]
    struct Foo(i32);
    let b = <Array<Foo, Ix0> as Default>::default();
    assert_eq!(b, arr0(Foo::default()));
}

#[test]
fn test_default_ixdyn() {
    let a = <Array<f32, IxDyn> as Default>::default();
    let b = <Array<f32, _>>::zeros(IxDyn(&[0]));
    assert_eq!(a, b);
}


#[test]
fn test_map_axis() {
    let a = arr2(&[[1, 2, 3],
                   [4, 5, 6],
                   [7, 8, 9],
                   [10,11,12]]);

    let b = a.map_axis(Axis(0), |view| view.sum());
    let answer1 = arr1(&[22, 26, 30]);
    assert_eq!(b, answer1);
    let c = a.map_axis(Axis(1), |view| view.sum());
    let answer2 = arr1(&[6, 15, 24, 33]);
    assert_eq!(c, answer2);
}

#[test]
fn test_to_vec() {
    let mut a = arr2(&[[1, 2, 3],
                       [4, 5, 6],
                       [7, 8, 9],
                       [10,11,12]]);

    a.slice_collapse(s![..;-1, ..]);
    assert_eq!(a.row(3).to_vec(), vec![1, 2, 3]);
    assert_eq!(a.column(2).to_vec(), vec![12, 9, 6, 3]);
    a.slice_collapse(s![.., ..;-1]);
    assert_eq!(a.row(3).to_vec(), vec![3, 2, 1]);
}

#[test]
fn test_array_clone_unalias() {
    let a = Array::<i32, _>::zeros((3, 3));
    let mut b = a.clone();
    b.fill(1);
    assert!(a != b);
    assert_eq!(a, Array::<_, _>::zeros((3, 3)));
}

#[test]
fn test_array_clone_same_view() {
    let mut a = Array::from_iter(0..9).into_shape((3, 3)).unwrap();
    a.slice_collapse(s![..;-1, ..;-1]);
    let b = a.clone();
    assert_eq!(a, b);
}

#[test]
fn array_macros() {
    // array
    let a1 = array![1, 2, 3];
    assert_eq!(a1, arr1(&[1, 2, 3]));
    let a2 = array![[1, 2], [3, 4], [5, 6]];
    assert_eq!(a2, arr2(&[[1, 2], [3, 4], [5, 6]]));
    let a3 = array![[[1, 2], [3, 4]], [[5, 6], [7, 8]]];
    assert_eq!(a3, arr3(&[[[1, 2], [3, 4]], [[5, 6], [7, 8]]]));
    let a4 = array![[[1, 2,], [3, 4,]], [[5, 6,], [7, 8,],],]; // trailing commas
    assert_eq!(a4, arr3(&[[[1, 2], [3, 4]], [[5, 6], [7, 8]]]));

    let s = String::from("abc");
    let a2s = array![[String::from("w"), s],
                     [String::from("x"), String::from("y")]];
    assert_eq!(a2s[[0, 0]], "w");
    assert_eq!(a2s[[0, 1]], "abc");
    assert_eq!(a2s[[1, 0]], "x");
    assert_eq!(a2s[[1, 1]], "y");

    let empty1: Array<f32, Ix1> = array![];
    assert_eq!(empty1, array![]);
    let empty2: Array<f32, Ix2> = array![[]];
    assert_eq!(empty2, array![[]]);
}