matamorph 0.2.0

#[cfg(test)]
mod tests {
    use matamorph::mut_::MataConvertMut;
    use matamorph::own::MataConvertOwn;
    use matamorph::ref_::MataConvertRef;

    // Owned conversions

    #[test]
    fn owned_ndarray_to_faer() {
        let a = ndarray::array![[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]];
        let b: faer::Mat<f64> = a.to_faer();

        dbg!(&b);

        assert_eq!(b.nrows(), 2);
        assert_eq!(b.ncols(), 3);

        assert_eq!(b[(0, 0)], 1.0);
        assert_eq!(a[(0, 0)], 1.0);

        assert_eq!(b[(1, 0)], 4.0);
        assert_eq!(a[(1, 0)], 4.0);

        assert_eq!(a[(0, 1)], 2.0);
        assert_eq!(b[(0, 1)], 2.0);
    }

    #[test]
    fn owned_mdarray_to_faer() {
        // let mut a =
        //     mdarray::Tensor::<f64, (mdarray::Const<2>, mdarray::Const<3>)>::from_elem([2, 3], 0.0);

        let mut a = mdarray::Tensor::<f64, (mdarray::Const<2>, mdarray::Const<3>)>::from_elem(
            (mdarray::Const::<2>, mdarray::Const::<3>),
            0.0,
        );

        // let mut a = mdarray::DTensor::<f64, 2>::from_elem([2, 3], 0.0);
        a[[0, 0]] = 1.0;
        a[[0, 1]] = 2.0;
        a[[1, 2]] = 6.0;

        let b: faer::Mat<f64> = a.to_faer();

        assert_eq!(b.nrows(), 2);
        assert_eq!(b.ncols(), 3);

        assert_eq!(b[(0, 0)], 1.0);
        assert_eq!(b[(0, 1)], 2.0);
        assert_eq!(b[(1, 2)], 6.0);
    }

    #[test]
    fn owned_nalgebra_to_faer() {
        let a = nalgebra::DMatrix::from_row_slice(2, 3, &[1.0, 2.0, 3.0, 4.0, 5.0, 6.0]);
        let b: faer::Mat<f64> = a.to_faer();

        assert_eq!(b.nrows(), 2);
        assert_eq!(b.ncols(), 3);

        assert_eq!(b[(0, 0)], 1.0);
        assert_eq!(a[(0, 0)], 1.0);

        assert_eq!(b[(0, 2)], 3.0);
        assert_eq!(a[(0, 2)], 3.0);

        assert_eq!(b[(1, 0)], 4.0);
        assert_eq!(a[(1, 0)], 4.0);
    }

    #[test]
    fn owned_faer_to_ndarray() {
        let a = faer::Mat::from_fn(2, 3, |i, j| (i * 3 + j + 1) as f64);
        let b: ndarray::Array2<f64> = a.to_ndarray();

        assert_eq!(b.shape(), &[2, 3]);
        assert_eq!(b[[0, 0]], 1.0);
        assert_eq!(b[[0, 2]], 3.0);
        assert_eq!(b[[1, 0]], 4.0);
        assert_eq!(b[[1, 2]], 6.0);
    }

    #[test]
    fn owned_faer_to_mdarray() {
        let a = faer::Mat::from_fn(3, 2, |_i, _j| 7.0);
        let b: mdarray::DTensor<f64, 2> = a.to_mdarray();

        assert_eq!(b.shape(), &(3, 2));
        assert!(b.iter().all(|&x| x == 7.0));
    }

    #[test]
    fn owned_faer_to_nalgebra() {
        let a = faer::Mat::from_fn(2, 3, |i, j| (i * 3 + j + 1) as f64);
        let b: nalgebra::DMatrix<f64> = a.to_nalgebra();

        assert_eq!(b.shape(), (2, 3));
        assert_eq!(b[(0, 0)], 1.0);

        assert_eq!(a[(0, 2)], 3.0);
        assert_eq!(b[(0, 2)], 3.0);

        assert_eq!(b[(1, 0)], 4.0);
        assert_eq!(b[(1, 2)], 6.0);
    }

    #[test]
    fn owned_ndarray_to_mdarray() {
        let a = ndarray::array![[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]];
        let b: mdarray::DTensor<f64, 2> = a.to_mdarray();

        assert_eq!(b.shape(), &(2, 3));
        assert_eq!(b[[0, 0]], 1.0);
        assert_eq!(b[[0, 1]], 2.0);
        assert_eq!(b[[1, 2]], 6.0);
    }

    #[test]
    fn owned_ndarray_to_nalgebra() {
        let a = ndarray::array![[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]];
        println!("{:?}", a);
        let b: nalgebra::DMatrix<f64> = a.clone().to_nalgebra();

        println!("{:?}", b);
        println!("{:?}", b.strides());

        assert_eq!(b.shape(), (2, 3));

        assert_eq!(b[(0, 0)], 1.0);
        assert_eq!(a[(0, 0)], 1.0);

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

        assert_eq!(a[(0, 2)], 3.0);
        assert_eq!(b[(0, 2)], 3.0);

        let a = ndarray::array![[1.0, 2.0], [3.0, 4.0]];
        let b: nalgebra::DMatrix<f64> = a.clone().to_nalgebra();
        assert_eq!(b[(1, 0)], a[(1, 0)]);
    }

    #[test]
    fn owned_mdarray_to_ndarray() {
        let a = mdarray::DTensor::<f64, 2>::from_elem([3, 2], 7.0);
        let b: ndarray::Array2<f64> = a.to_ndarray();

        assert_eq!(b.shape(), &[3, 2]);
        assert!(b.iter().all(|&x| x == 7.0));
    }

    #[test]
    fn owned_mdarray_to_nalgebra() {
        let mut a = mdarray::DTensor::<f64, 2>::from_elem([2, 2], 0.0);
        a[[0, 0]] = 1.0;
        a[[1, 1]] = 2.0;

        let b: nalgebra::DMatrix<f64> = a.to_nalgebra();

        assert_eq!(b[(0, 0)], 1.0);
        assert_eq!(b[(1, 1)], 2.0);
    }

    #[test]
    fn owned_nalgebra_to_ndarray() {
        let a = nalgebra::DMatrix::from_row_slice(2, 3, &[1.0, 2.0, 3.0, 4.0, 5.0, 6.0]);
        println!("{:?}", a[(0, 2)]);
        let b: ndarray::Array2<f64> = a.to_ndarray();

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

        assert_eq!(b.shape(), &[2, 3]);
        assert_eq!(b[[0, 2]], 3.0);
        assert_eq!(b[[1, 0]], 4.0);
    }

    #[test]
    fn owned_nalgebra_to_mdarray() {
        let a = nalgebra::DMatrix::from_element(4, 3, 9.0);
        let b: mdarray::DTensor<f64, 2> = a.to_mdarray();

        assert_eq!(b.shape(), &(4, 3));
        assert!(b.iter().all(|&x| x == 9.0));
    }

    #[test]
    fn owned_roundtrip_ndarray() {
        let original = ndarray::array![[1.0, 2.0], [3.0, 4.0]];
        let converted: ndarray::Array2<f64> = original
            .clone()
            .to_nalgebra()
            .to_mdarray::<mdarray::Const<2>, mdarray::Const<2>>()
            .to_nalgebra()
            .to_ndarray();
        // Even though we convert two times to
        // nalgebra, the final result is still transposed.

        for i in 0..2 {
            for j in 0..2 {
                assert_eq!(original[[i, j]], converted[[j, i]]);
            }
        }
    }

    #[test]
    fn owned_roundtrip_mdarray() {
        let mut original = mdarray::DTensor::<f64, 2>::from_elem([3, 3], 0.0);
        for i in 0..3 {
            for j in 0..3 {
                original[[i, j]] = (i * 3 + j) as f64;
            }
        }

        let converted: mdarray::DTensor<f64, 2> =
            original.clone().to_nalgebra().to_ndarray().to_mdarray();

        for i in 0..3 {
            for j in 0..3 {
                assert_eq!(original[[i, j]], converted[[i, j]]);
            }
        }
    }

    #[test]
    fn owned_roundtrip_nalgebra() {
        let original = nalgebra::DMatrix::from_row_slice(2, 2, &[1.0, 2.0, 3.0, 4.0]);
        let converted: nalgebra::DMatrix<f64> = original
            .clone()
            .to_ndarray()
            .to_mdarray::<mdarray::Const<2>, mdarray::Const<2>>()
            .to_nalgebra();

        assert_eq!(original, converted);
    }

    // Ref conversions

    #[test]
    fn ref_ndarray_to_mdarray() {
        let a = ndarray::array![[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]];
        let a_view = a.view();
        let b = a_view.to_mdarray();

        assert_eq!(b.shape(), &(2, 3));
        assert_eq!(b[[0, 0]], 1.0);
        assert_eq!(b[[1, 2]], 6.0);
    }

    #[test]
    fn ref_ndarray_to_faer() {
        let a = ndarray::array![[1.0, 2.0], [3.0, 4.0]];
        let a_view = a.view();
        let b = a_view.to_faer();

        assert_eq!(b.nrows(), 2);
        assert_eq!(b.ncols(), 2);
        assert_eq!(b[(0, 1)], 2.0);
    }

    #[test]
    fn ref_ndarray_to_nalgebra() {
        let a = ndarray::array![[1.0, 2.0], [3.0, 4.0]];
        let a_view = a.view();
        let b = a_view.to_nalgebra();
        assert_eq!(b.shape(), (2, 2));
        assert_eq!(b[(0, 1)], 3.0);
    }

    #[test]
    fn mut_ndarray_to_nalgebra() {
        let mut a = ndarray::array![[1.0, 2.0, 10.], [3.0, 4.0, 10.], [5.0, 6.0, 10.]];
        let a_view = a.view_mut();
        let b = a_view.to_nalgebra();

        assert_eq!(b.shape(), (3, 3));
        assert_eq!(b[(1, 2)], 6.0); // transpose
    }

    #[test]
    fn ref_mdarray_to_ndarray() {
        let a = mdarray::DTensor::<f64, 2>::from_elem([2, 3], 5.0);

        let b = a.to_ndarray();

        assert_eq!(b.shape(), &[2, 3]);
        assert!(b.iter().all(|&x| x == 5.0));
    }

    #[test]
    fn ref_mdarray_to_faer() {
        let mut a = mdarray::DTensor::<f64, 2>::from_elem([2, 2], 0.0);
        a[[0, 0]] = 1.0;
        a[[1, 1]] = 4.0;

        let a_view = a.view(.., ..);

        let b = a_view.to_faer();

        assert_eq!(b[(0, 0)], 1.0);
        assert_eq!(b[(1, 1)], 4.0);
    }

    #[test]
    fn ref_mdarray_to_nalgebra() {
        let a = mdarray::DTensor::<f32, 2>::from_elem([3, 3], 2.0);

        let (m, n) = (3, 3);
        let a = mdarray::DTensor::<f64, 2>::from_fn([m, n], |i| (i[0] * i[1] + i[0] + 1) as f64);
        assert_eq!(a[[2, 2]], 7.0);

        let b = a.view(.., ..).to_nalgebra();

        assert_eq!(b.shape(), (m, n));
        for i in 0..m {
            for j in 0..n {
                dbg!(b[(i, j)]);
            }
        }
        assert_eq!(b[(2, 2)], 7.0);
    }

    #[test]
    fn ref_faer_to_ndarray() {
        let a = faer::mat![[1.0, 2.0], [3.0, 4.0]];
        let a_ref = a.as_ref();
        let b = a_ref.to_ndarray();

        assert_eq!(b[[0, 0]], 1.0);
        assert_eq!(b[[1, 1]], 4.0);
    }

    #[test]
    fn ref_faer_to_mdarray() {
        let a = faer::mat![[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]];
        let a_ref = a.as_ref();
        let b = a_ref.to_mdarray();

        assert_eq!(b.shape(), &(2, 3));
        assert_eq!(b[[1, 2]], 6.0);
    }

    #[test]
    fn ref_faer_to_nalgebra() {
        let a = faer::mat![[1.0, 2.0], [3.0, 4.0]];
        let a_ref = a.as_ref();
        let b = a_ref.to_nalgebra();

        assert_eq!(b.shape(), (2, 2));
        assert_eq!(b[(1, 0)], 3.0);
    }

    #[test]
    fn ref_nalgebra_to_ndarray() {
        let a = nalgebra::DMatrix::from_row_slice(2, 2, &[1.0, 2.0, 3.0, 4.0]);
        let a_view = a.view((0, 0), (2, 2));
        let b = a_view.to_ndarray();

        assert_eq!(b[[0, 0]], 1.0);
        assert_eq!(b[[1, 1]], 4.0);
    }

    #[test]
    fn ref_nalgebra_to_mdarray() {
        let a = nalgebra::dmatrix![1.0, 2.0, 3.0; 4.0, 5.0, 6.0];
        let a_view = a.view((0, 0), (2, 3));
        let b = a_view.to_mdarray();

        assert_eq!(b.shape(), &(2, 3));
        assert_eq!(b[[1, 1]], 5.0);
    }

    #[test]
    fn ref_nalgebra_to_faer() {
        let a = nalgebra::dmatrix![1.0, 2.0; 3.0, 4.0];
        let a_view = a.view((0, 0), (2, 2));
        let b = a_view.to_faer();

        assert_eq!(b[(0, 1)], 2.0);
        assert_eq!(b[(1, 0)], 3.0);
    }

    #[test]
    fn ref_chain_conversions() {
        let original = ndarray::array![[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]];

        let view = original.view();
        let mdarray_view = view.to_mdarray::<usize, usize>();
        let faer_view = mdarray_view.to_faer();
        dbg!(original.strides());
        // let faer_view = view.to_faer();
        dbg!(faer_view.row_stride(), faer_view.col_stride());
        let original_faer = faer::mat![[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]];
        let original_faer_view = original_faer.as_ref();
        dbg!(
            original_faer_view.row_stride(),
            original_faer_view.col_stride()
        );
        let nalgebra_view = faer_view.to_nalgebra();
        // let nalgebra_view = original_faer_view.to_nalgebra();
        // let nalgebra_view = view.to_nalgebra();
        dbg!("{:?}", &original);
        let back_to_ndarray = nalgebra_view.to_ndarray();

        dbg!("{:?}", &back_to_ndarray);

        for i in 0..3 {
            for j in 0..3 {
                assert_eq!(original[[i, j]], back_to_ndarray[[j, i]]);
            }
        }
    }

    // Mut conversions with modifications

    #[test]
    fn mut_ndarray_to_mdarray_modification() {
        let mut a = ndarray::array![[1.0, 2.0], [3.0, 4.0]];
        {
            let mut b = a.view_mut().to_mdarray::<usize, usize>();
            b[[0, 0]] = 99.0;
            b[[1, 1]] = 88.0;
        }

        assert_eq!(a[[0, 0]], 99.0);
        assert_eq!(a[[1, 1]], 88.0);
    }

    #[test]
    fn mut_ndarray_to_faer_modification() {
        let mut a = ndarray::array![[1.0, 2.0], [3.0, 4.0]];
        {
            let mut b = a.view_mut().to_faer();
            b[(0, 0)] = 77.0;
            b[(1, 1)] = 66.0;
        }

        assert_eq!(a[[0, 0]], 77.0);
        assert_eq!(a[[1, 1]], 66.0);
    }

    #[test]
    fn mut_ndarray_to_nalgebra_modification() {
        let mut a = ndarray::array![[1.0, 2.0, 10.], [3.0, 4.0, 10.], [5.0, 6.0, 10.]];
        {
            let mut b = a.view_mut().to_nalgebra();
            b[(0, 2)] = 33.0;
            b[(1, 1)] = 44.0;
        }

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

        assert_eq!(a[[2, 0]], 33.0);
        assert_eq!(a[[1, 1]], 44.0);
    }

    #[test]
    fn mut_mdarray_to_ndarray_modification() {
        let mut a = mdarray::DTensor::<f64, 2>::from_elem([2, 3], 1.0);
        {
            let mut b = a.view_mut(.., ..).to_ndarray();
            b[[0, 2]] = 55.0;
            b[[1, 1]] = 44.0;
        }

        assert_eq!(a[[0, 2]], 55.0);
        assert_eq!(a[[1, 1]], 44.0);
    }

    #[test]
    fn mut_mdarray_to_faer_modification() {
        let mut a = mdarray::DTensor::<f64, 2>::from_elem([3, 2], 2.0);
        {
            let b_view = a.view_mut(.., ..);
            let mut b = b_view.to_faer();
            b[(2, 1)] = 33.0
        }
        println!("{:?}", a);
        assert_eq!(a[[2, 1]], 33.0);
    }

    #[test]
    fn mut_mdarray_to_nalgebra_modification() {
        let z = nalgebra::matrix![1, 2; 3, 4];
        println!("{}", z[1]);
        println!("{}", z[0]);

        let mut a = mdarray::DTensor::<f64, 2>::from_elem([3, 3], 0.0);

        {
            let mut b = a.view_mut(.., ..).to_nalgebra();

            b[(1, 1)] = 11.0;
            b[(2, 0)] = 22.0;
            println!("{:?}", b.to_ndarray());
        }
        println!("{:?}", a.stride(0));
        println!("{:?}", a.stride(1));
        println!("{:?}", a);
        assert_eq!(a[[1, 1]], 11.0);
        assert_eq!(a[[0, 2]], 22.0); // transpose
    }

    #[test]
    fn mut_faer_to_ndarray_modification() {
        let mut a = faer::Mat::<f64>::zeros(2, 2);
        {
            let mut b = a.as_mut().to_ndarray();
            b[[0, 0]] = 11.0;
            b[[1, 0]] = 22.0;
        }
        assert_eq!(a[(0, 0)], 11.0);
        assert_eq!(a[(1, 0)], 22.0);
    }

    #[test]
    fn mut_faer_to_mdarray_modification() {
        let mut a = faer::Mat::<f64>::zeros(3, 2);
        {
            let mut b = a.as_mut().to_mdarray::<usize, usize>();
            b[[0, 1]] = 15.0;
            b[[2, 0]] = 25.0;
        }

        assert_eq!(a[(0, 1)], 15.0);
        assert_eq!(a[(2, 0)], 25.0);
    }

    #[test]
    fn mut_faer_to_nalgebra_modification() {
        let mut a = faer::Mat::<f64>::zeros(3, 3);
        {
            let mut b = a.as_mut().to_nalgebra();
            b[(1, 2)] = 99.0;
        }
        dbg!("{:?}", &a);
        assert_eq!(a[(1, 2)], 99.0);
    }

    #[test]
    fn mut_nalgebra_to_ndarray_modification() {
        let mut a = nalgebra::DMatrix::zeros(2, 3);
        {
            let a_view = a.view_mut((0, 0), (2, 3));
            let mut b = a_view.to_ndarray();
            b[[1, 2]] = 99.0;
        }

        assert_eq!(a[(1, 2)], 99.0);
    }

    #[test]
    fn mut_nalgebra_to_mdarray_modification() {
        let mut a = nalgebra::DMatrix::zeros(3, 3);
        {
            let a_view = a.view_mut((0, 0), (3, 3));
            let mut b = a_view.to_mdarray::<usize, usize>();
            b[[0, 0]] = 10.0;
            b[[2, 2]] = 20.0;
        }

        assert_eq!(a[(0, 0)], 10.0);
        assert_eq!(a[(2, 2)], 20.0);
    }

    #[test]
    fn mut_nalgebra_to_faer_modification() {
        let mut a = nalgebra::DMatrix::zeros(2, 2);
        {
            let a_view = a.view_mut((0, 0), (2, 2));
            let mut b = a_view.to_faer();
            b[(0, 1)] = 12.0;
            b[(1, 0)] = 21.0;
        }

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

        assert_eq!(a[(0, 1)], 12.0);
        assert_eq!(a[(1, 0)], 21.0);
    }

    #[test]
    fn mut_modify_all_elements() {
        let mut a = ndarray::Array2::<f64>::zeros((3, 3));

        {
            let mut b = a.view_mut().to_mdarray::<usize, usize>();
            for i in 0..3 {
                for j in 0..3 {
                    b[[i, j]] = (i * 3 + j) as f64;
                }
            }
        }

        for i in 0..3 {
            for j in 0..3 {
                assert_eq!(a[[i, j]], (i * 3 + j) as f64);
            }
        }
    }

    // Rectangular matrices

    #[test]
    fn rectangular_2x5() {
        let a = ndarray::Array2::<f64>::zeros((2, 5));
        let b = a.view().to_mdarray::<usize, usize>();
        let c = b.to_faer();

        assert_eq!(c.nrows(), 2);
        assert_eq!(c.ncols(), 5);
    }

    #[test]
    fn rectangular_7x3() {
        let a = mdarray::DTensor::<f64, 2>::from_elem([7, 3], 1.0);
        let b = a.to_nalgebra();
        assert_eq!(b.shape(), (7, 3));
    }

    #[test]
    fn rectangular_1xn() {
        let a = ndarray::Array2::<f64>::from_elem((1, 10), 5.0);
        let b = a.view().to_faer();

        assert_eq!(b.nrows(), 1);
        assert_eq!(b.ncols(), 10);
        assert_eq!(b[(0, 9)], 5.0);
    }

    #[test]
    fn rectangular_nx1() {
        let a = nalgebra::DMatrix::from_element(8, 1, 3.0);
        let b = a.view((0, 0), (8, 1)).to_ndarray();

        assert_eq!(b.shape(), &[8, 1]);
        assert_eq!(b[[7, 0]], 3.0);
    }

    #[test]
    fn rectangular_10x2() {
        let mut a = faer::Mat::<f64>::zeros(10, 2);
        {
            let mut b = a.as_mut().to_ndarray();
            b[[5, 1]] = 42.0;
        }

        assert_eq!(a[(5, 1)], 42.0);
    }

    #[test]
    fn rectangular_3x7_owned() {
        let a = ndarray::Array2::<f64>::from_elem((7, 3), 8.0);
        println!("{:?}", a);
        let b: nalgebra::DMatrix<f64> = a.to_nalgebra();

        assert_eq!(b.shape(), (7, 3));
        assert_eq!(b[(6, 2)], 8.0);
    }

    // Strides and transposition

    #[test]
    fn ndarray_transposed_to_mdarray() {
        let a = ndarray::array![[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]];
        let a_t = a.t();
        let b = a_t.to_mdarray();

        assert_eq!(b.shape(), &(3, 2));
        assert_eq!(b[[0, 0]], 1.0);
        assert_eq!(b[[0, 1]], 4.0);
        assert_eq!(b[[2, 1]], 6.0);
    }

    #[test]
    fn ndarray_transposed_to_faer() {
        let a = ndarray::array![[1.0, 2.0], [3.0, 4.0]];
        let a_t = a.t();
        let b = a_t.to_faer();

        assert_eq!(b[(0, 0)], 1.0);
        assert_eq!(b[(0, 1)], 3.0);
        assert_eq!(b[(1, 0)], 2.0);
    }

    #[test]
    fn ndarray_transposed_to_nalgebra() {
        let a = ndarray::array![[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [4.0, 5.0, 6.0]];
        // let a = ndarray::array![[1.0, 2.0,], [3.0, 4.0], [5.0, 6.0]];
        println!("{:?}", a);
        println!("{:?}", a.clone().into_raw_vec_and_offset());
        let a_t = a.t(); // ref or mut not owned
        println!("{:?}", a_t);

        let b = a_t.to_nalgebra();
        dbg!(&b);
        assert_eq!(b.shape(), (3, 3));
        assert_eq!(a[(1, 2)], 6.0);
        assert_eq!(b[(2, 1)], 6.0);
    }

    #[test]
    fn ndarray_slice_with_stride() {
        let a = ndarray::array![
            [1.0, 2.0, 3.0, 4.0],
            [5.0, 6.0, 7.0, 8.0],
            [9.0, 10.0, 11.0, 12.0]
        ];

        let sliced = a.slice(ndarray::s![.., ..;2]);
        let b = sliced.to_mdarray();

        assert_eq!(b.shape(), &(3, 2));
        assert_eq!(b[[0, 0]], 1.0);
        assert_eq!(b[[0, 1]], 3.0);
        assert_eq!(b[[2, 1]], 11.0);
    }

    #[test]
    fn ndarray_slice_rows_with_stride() {
        let a = ndarray::array![[1.0, 2.0], [3.0, 4.0], [5.0, 6.0], [7.0, 8.0]];

        let sliced = a.slice(ndarray::s![..;2, ..]);
        let b = sliced.to_faer();

        println!("{:?}", b);
        assert_eq!(b.nrows(), 2);
        assert_eq!(b[(0, 0)], 1.0);
        assert_eq!(b[(1, 1)], 6.0);
    }

    #[test]
    fn ndarray_mut_transposed_modification() {
        let mut a = ndarray::array![[1.0, 2.0], [3.0, 4.0]];
        {
            let a_t = a.view_mut().reversed_axes();
            let mut b = a_t.to_mdarray::<usize, usize>();
            b[[0, 1]] = 99.0;
        }

        assert_eq!(a[[1, 0]], 99.0);
    }

    #[test]
    fn ndarray_mut_transposed_to_faer() {
        let mut a = ndarray::array![[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]];
        {
            let a_t = a.view_mut().reversed_axes();
            let mut b = a_t.to_faer();
            b[(1, 1)] = 88.0;
        }

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

    #[test]
    fn ndarray_slice_mut_modification() {
        let mut a = ndarray::Array2::<f64>::zeros((4, 4));
        {
            let sliced = a.slice_mut(ndarray::s![1..3, 1..3]);
            let mut b = sliced.to_mdarray::<usize, usize>();
            b[[0, 0]] = 10.0;
            b[[1, 1]] = 20.0;
        }

        assert_eq!(a[[1, 1]], 10.0);
        assert_eq!(a[[2, 2]], 20.0);
    }

    // Edge cases

    #[test]
    fn single_element_matrix() {
        let a = ndarray::array![[42.0]];
        let b = a.view().to_mdarray::<usize, usize>();
        let c = b.to_faer();
        let d = c.to_nalgebra();

        assert_eq!(d[(0, 0)], 42.0);
    }

    #[test]
    fn single_element_owned() {
        let a = ndarray::array![[7.0]];
        let b: nalgebra::DMatrix<f64> = a.to_nalgebra();

        assert_eq!(b[(0, 0)], 7.0);
    }

    #[test]
    fn single_row() {
        let a = ndarray::array![[1.0, 2.0, 3.0, 4.0, 5.0]];
        let b = a.view().to_faer();

        assert_eq!(b.nrows(), 1);
        assert_eq!(b.ncols(), 5);
    }

    #[test]
    #[should_panic]
    fn single_column() {
        // panics because rectangular matrices conversion with nalgebra is not yet supported
        let a = faer::mat![[1.0], [2.0], [3.0], [4.0]];
        let b = a.as_ref().to_nalgebra();

        assert_eq!(b.shape(), (4, 1));
        assert_eq!(b[(3, 0)], 4.0);
    }

    #[test]
    fn large_matrix() {
        let a = ndarray::Array2::<f64>::zeros((100, 50));
        let b = a.view().to_mdarray::<usize, usize>();
        let c = b.to_faer();

        assert_eq!(c.nrows(), 100);
        assert_eq!(c.ncols(), 50);
    }

    #[test]
    fn large_matrix_owned() {
        let a = mdarray::DTensor::<f64, 2>::from_elem([80, 120], 1.5);
        let b: ndarray::Array2<f64> = a.to_ndarray();

        assert_eq!(b.shape(), &[80, 120]);
    }

    #[test]
    fn square_matrices_various_sizes() {
        for size in [1, 2, 5, 10, 20] {
            let a = ndarray::Array2::<f64>::eye(size);
            let b = a.view().to_faer();

            assert_eq!(b.nrows(), size);
            assert_eq!(b.ncols(), size);

            for i in 0..size {
                assert_eq!(b[(i, i)], 1.0);
            }
        }
    }

    #[test]
    fn matmul_integration() {
        let a = faer::mat![[1.0, 2.0], [3.0, 4.0]];
        let b = nalgebra::dmatrix![5.0, 6.0; 7.0, 8.0];

        let a_md = a
            .as_ref()
            .to_mdarray::<mdarray::Const<2>, mdarray::Const<2>>();

        let b_md = b.view((0, 0), (2, 2)).to_mdarray::<usize, usize>();

        assert_eq!(a_md[[0, 0]], 1.0);
        assert_eq!(b_md[[0, 0]], 5.0);
    }
}