ndarray-ndimage 0.6.0

use approx::assert_relative_eq;
use ndarray::{arr1, arr2, arr3, Array1, Array2, Array3};

use ndarray_ndimage::{pad, PadMode};

fn simple_data_1d() -> Array1<u16> {
    arr1(&[0, 1, 2, 3])
}

fn simple_data_2d() -> Array2<f64> {
    (0..12).map(|v| v as f64).collect::<Array1<_>>().into_shape_with_order((3, 4)).unwrap()
}

fn simple_data_3d() -> Array3<f64> {
    (0..24).map(|v| v as f64).collect::<Array1<_>>().into_shape_with_order((2, 3, 4)).unwrap()
}

#[test] // Results verified with the `pad(mode='maximum')` function from NumPy. (v1.21.4)
fn test_pad_minmax() {
    let data = simple_data_1d();
    assert_eq!(pad(&data, &[[1, 0]], PadMode::Minimum), arr1(&[0, 0, 1, 2, 3]));
    assert_eq!(pad(&data, &[[0, 1]], PadMode::Minimum), arr1(&[0, 1, 2, 3, 0]));
    assert_eq!(pad(&data, &[[1, 1]], PadMode::Minimum), arr1(&[0, 0, 1, 2, 3, 0]));
    assert_eq!(pad(&data, &[[2, 2]], PadMode::Maximum), arr1(&[3, 3, 0, 1, 2, 3, 3, 3]));
    assert_eq!(pad(&data, &[[2, 2]], PadMode::Minimum), arr1(&[0, 0, 0, 1, 2, 3, 0, 0]));

    let data = simple_data_2d();
    assert_relative_eq!(
        pad(&data, &[[1, 1], [2, 2]], PadMode::Maximum),
        arr2(&[
            [11.0, 11.0, 8.0, 9.0, 10.0, 11.0, 11.0, 11.0],
            [3.0, 3.0, 0.0, 1.0, 2.0, 3.0, 3.0, 3.0],
            [7.0, 7.0, 4.0, 5.0, 6.0, 7.0, 7.0, 7.0],
            [11.0, 11.0, 8.0, 9.0, 10.0, 11.0, 11.0, 11.0],
            [11.0, 11.0, 8.0, 9.0, 10.0, 11.0, 11.0, 11.0]
        ])
    );
    assert_relative_eq!(
        pad(&data, &[[1, 1], [2, 2]], PadMode::Minimum),
        arr2(&[
            [0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 0.0, 0.0],
            [0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 0.0, 0.0],
            [4.0, 4.0, 4.0, 5.0, 6.0, 7.0, 4.0, 4.0],
            [8.0, 8.0, 8.0, 9.0, 10.0, 11.0, 8.0, 8.0],
            [0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 0.0, 0.0]
        ])
    );

    let data = simple_data_3d();
    assert_relative_eq!(
        pad(&data.view(), &[[0, 0], [1, 1], [2, 2]], PadMode::Maximum),
        arr3(&[
            [
                [11.0, 11.0, 8.0, 9.0, 10.0, 11.0, 11.0, 11.0],
                [3.0, 3.0, 0.0, 1.0, 2.0, 3.0, 3.0, 3.0],
                [7.0, 7.0, 4.0, 5.0, 6.0, 7.0, 7.0, 7.0],
                [11.0, 11.0, 8.0, 9.0, 10.0, 11.0, 11.0, 11.0],
                [11.0, 11.0, 8.0, 9.0, 10.0, 11.0, 11.0, 11.0]
            ],
            [
                [23.0, 23.0, 20.0, 21.0, 22.0, 23.0, 23.0, 23.0],
                [15.0, 15.0, 12.0, 13.0, 14.0, 15.0, 15.0, 15.0],
                [19.0, 19.0, 16.0, 17.0, 18.0, 19.0, 19.0, 19.0],
                [23.0, 23.0, 20.0, 21.0, 22.0, 23.0, 23.0, 23.0],
                [23.0, 23.0, 20.0, 21.0, 22.0, 23.0, 23.0, 23.0]
            ]
        ])
    );
    assert_relative_eq!(
        pad(&data.view(), &[[0, 0], [1, 1], [2, 2]], PadMode::Minimum),
        arr3(&[
            [
                [0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 0.0, 0.0],
                [0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 0.0, 0.0],
                [4.0, 4.0, 4.0, 5.0, 6.0, 7.0, 4.0, 4.0],
                [8.0, 8.0, 8.0, 9.0, 10.0, 11.0, 8.0, 8.0],
                [0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 0.0, 0.0]
            ],
            [
                [12.0, 12.0, 12.0, 13.0, 14.0, 15.0, 12.0, 12.0],
                [12.0, 12.0, 12.0, 13.0, 14.0, 15.0, 12.0, 12.0],
                [16.0, 16.0, 16.0, 17.0, 18.0, 19.0, 16.0, 16.0],
                [20.0, 20.0, 20.0, 21.0, 22.0, 23.0, 20.0, 20.0],
                [12.0, 12.0, 12.0, 13.0, 14.0, 15.0, 12.0, 12.0]
            ]
        ])
    );
}

#[test] // Results verified with the `pad(mode='mean')` function from NumPy. (v1.21.4)
fn test_pad_mean() {
    let data = simple_data_1d();
    assert_eq!(pad(&data, &[[2, 2]], PadMode::Mean), arr1(&[1, 1, 0, 1, 2, 3, 1, 1]));
    assert_eq!(pad(&arr1(&[1, 2, 3]), &[[2, 2]], PadMode::Mean), arr1(&[2, 2, 1, 2, 3, 2, 2]));

    let data = simple_data_2d();
    assert_relative_eq!(
        pad(&data, &[[1, 1], [2, 2]], PadMode::Mean),
        arr2(&[
            [5.5, 5.5, 4.0, 5.0, 6.0, 7.0, 5.5, 5.5],
            [1.5, 1.5, 0.0, 1.0, 2.0, 3.0, 1.5, 1.5],
            [5.5, 5.5, 4.0, 5.0, 6.0, 7.0, 5.5, 5.5],
            [9.5, 9.5, 8.0, 9.0, 10.0, 11.0, 9.5, 9.5],
            [5.5, 5.5, 4.0, 5.0, 6.0, 7.0, 5.5, 5.5]
        ])
    );

    let data = simple_data_3d();
    assert_relative_eq!(
        pad(&data.view(), &[[0, 0], [1, 1], [2, 2]], PadMode::Mean),
        arr3(&[
            [
                [5.5, 5.5, 4.0, 5.0, 6.0, 7.0, 5.5, 5.5],
                [1.5, 1.5, 0.0, 1.0, 2.0, 3.0, 1.5, 1.5],
                [5.5, 5.5, 4.0, 5.0, 6.0, 7.0, 5.5, 5.5],
                [9.5, 9.5, 8.0, 9.0, 10.0, 11.0, 9.5, 9.5],
                [5.5, 5.5, 4.0, 5.0, 6.0, 7.0, 5.5, 5.5]
            ],
            [
                [17.5, 17.5, 16.0, 17.0, 18.0, 19.0, 17.5, 17.5],
                [13.5, 13.5, 12.0, 13.0, 14.0, 15.0, 13.5, 13.5],
                [17.5, 17.5, 16.0, 17.0, 18.0, 19.0, 17.5, 17.5],
                [21.5, 21.5, 20.0, 21.0, 22.0, 23.0, 21.5, 21.5],
                [17.5, 17.5, 16.0, 17.0, 18.0, 19.0, 17.5, 17.5]
            ]
        ])
    );
}

#[test] // Results verified with the `pad(mode='median')` function from NumPy. (v1.21.4)
fn test_pad_median() {
    let data = simple_data_1d();
    assert_eq!(pad(&data, &[[2, 2]], PadMode::Median), arr1(&[1, 1, 0, 1, 2, 3, 1, 1]));
    assert_eq!(pad(&arr1(&[1, 2, 3]), &[[2, 2]], PadMode::Median), arr1(&[2, 2, 1, 2, 3, 2, 2]));

    let data = simple_data_2d();
    assert_relative_eq!(
        pad(&data, &[[1, 1], [2, 2]], PadMode::Median),
        arr2(&[
            [5.5, 5.5, 4.0, 5.0, 6.0, 7.0, 5.5, 5.5],
            [1.5, 1.5, 0.0, 1.0, 2.0, 3.0, 1.5, 1.5],
            [5.5, 5.5, 4.0, 5.0, 6.0, 7.0, 5.5, 5.5],
            [9.5, 9.5, 8.0, 9.0, 10.0, 11.0, 9.5, 9.5],
            [5.5, 5.5, 4.0, 5.0, 6.0, 7.0, 5.5, 5.5]
        ])
    );

    let data = simple_data_3d();
    assert_relative_eq!(
        pad(&data.view(), &[[0, 0], [1, 1], [2, 2]], PadMode::Median),
        arr3(&[
            [
                [5.5, 5.5, 4.0, 5.0, 6.0, 7.0, 5.5, 5.5],
                [1.5, 1.5, 0.0, 1.0, 2.0, 3.0, 1.5, 1.5],
                [5.5, 5.5, 4.0, 5.0, 6.0, 7.0, 5.5, 5.5],
                [9.5, 9.5, 8.0, 9.0, 10.0, 11.0, 9.5, 9.5],
                [5.5, 5.5, 4.0, 5.0, 6.0, 7.0, 5.5, 5.5]
            ],
            [
                [17.5, 17.5, 16.0, 17.0, 18.0, 19.0, 17.5, 17.5],
                [13.5, 13.5, 12.0, 13.0, 14.0, 15.0, 13.5, 13.5],
                [17.5, 17.5, 16.0, 17.0, 18.0, 19.0, 17.5, 17.5],
                [21.5, 21.5, 20.0, 21.0, 22.0, 23.0, 21.5, 21.5],
                [17.5, 17.5, 16.0, 17.0, 18.0, 19.0, 17.5, 17.5]
            ]
        ])
    );
}

#[test] // Results verified with the `pad(mode='reflect')` function from NumPy. (v1.21.4)
fn test_pad_reflect() {
    let data = simple_data_1d();
    assert_eq!(pad(&data, &[[1, 0]], PadMode::Reflect), arr1(&[1, 0, 1, 2, 3]));
    assert_eq!(pad(&data, &[[0, 1]], PadMode::Reflect), arr1(&[0, 1, 2, 3, 2]));
    assert_eq!(pad(&data, &[[1, 1]], PadMode::Reflect), arr1(&[1, 0, 1, 2, 3, 2]));
    assert_eq!(pad(&data, &[[2, 2]], PadMode::Reflect), arr1(&[2, 1, 0, 1, 2, 3, 2, 1]));

    let data = simple_data_2d();
    assert_relative_eq!(
        pad(&data, &[[1, 1], [1, 1],], PadMode::Reflect),
        arr2(&[
            [5.0, 4.0, 5.0, 6.0, 7.0, 6.0],
            [1.0, 0.0, 1.0, 2.0, 3.0, 2.0],
            [5.0, 4.0, 5.0, 6.0, 7.0, 6.0],
            [9.0, 8.0, 9.0, 10.0, 11.0, 10.0],
            [5.0, 4.0, 5.0, 6.0, 7.0, 6.0]
        ])
    );
    assert_relative_eq!(
        pad(&data, &[[1, 1], [2, 2]], PadMode::Reflect),
        arr2(&[
            [6.0, 5.0, 4.0, 5.0, 6.0, 7.0, 6.0, 5.0],
            [2.0, 1.0, 0.0, 1.0, 2.0, 3.0, 2.0, 1.0],
            [6.0, 5.0, 4.0, 5.0, 6.0, 7.0, 6.0, 5.0],
            [10.0, 9.0, 8.0, 9.0, 10.0, 11.0, 10.0, 9.0],
            [6.0, 5.0, 4.0, 5.0, 6.0, 7.0, 6.0, 5.0]
        ])
    );

    let data = simple_data_3d();
    assert_relative_eq!(
        pad(&data, &[[1, 1], [1, 1], [1, 1]], PadMode::Reflect),
        arr3(&[
            [
                [17.0, 16.0, 17.0, 18.0, 19.0, 18.0],
                [13.0, 12.0, 13.0, 14.0, 15.0, 14.0],
                [17.0, 16.0, 17.0, 18.0, 19.0, 18.0],
                [21.0, 20.0, 21.0, 22.0, 23.0, 22.0],
                [17.0, 16.0, 17.0, 18.0, 19.0, 18.0]
            ],
            [
                [5.0, 4.0, 5.0, 6.0, 7.0, 6.0],
                [1.0, 0.0, 1.0, 2.0, 3.0, 2.0],
                [5.0, 4.0, 5.0, 6.0, 7.0, 6.0],
                [9.0, 8.0, 9.0, 10.0, 11.0, 10.0],
                [5.0, 4.0, 5.0, 6.0, 7.0, 6.0]
            ],
            [
                [17.0, 16.0, 17.0, 18.0, 19.0, 18.0],
                [13.0, 12.0, 13.0, 14.0, 15.0, 14.0],
                [17.0, 16.0, 17.0, 18.0, 19.0, 18.0],
                [21.0, 20.0, 21.0, 22.0, 23.0, 22.0],
                [17.0, 16.0, 17.0, 18.0, 19.0, 18.0]
            ],
            [
                [5.0, 4.0, 5.0, 6.0, 7.0, 6.0],
                [1.0, 0.0, 1.0, 2.0, 3.0, 2.0],
                [5.0, 4.0, 5.0, 6.0, 7.0, 6.0],
                [9.0, 8.0, 9.0, 10.0, 11.0, 10.0],
                [5.0, 4.0, 5.0, 6.0, 7.0, 6.0]
            ]
        ])
    );
    assert_relative_eq!(
        pad(&data.view(), &[[0, 0], [1, 1], [2, 2]], PadMode::Reflect),
        arr3(&[
            [
                [6.0, 5.0, 4.0, 5.0, 6.0, 7.0, 6.0, 5.0],
                [2.0, 1.0, 0.0, 1.0, 2.0, 3.0, 2.0, 1.0],
                [6.0, 5.0, 4.0, 5.0, 6.0, 7.0, 6.0, 5.0],
                [10.0, 9.0, 8.0, 9.0, 10.0, 11.0, 10.0, 9.0],
                [6.0, 5.0, 4.0, 5.0, 6.0, 7.0, 6.0, 5.0]
            ],
            [
                [18.0, 17.0, 16.0, 17.0, 18.0, 19.0, 18.0, 17.0],
                [14.0, 13.0, 12.0, 13.0, 14.0, 15.0, 14.0, 13.0],
                [18.0, 17.0, 16.0, 17.0, 18.0, 19.0, 18.0, 17.0],
                [22.0, 21.0, 20.0, 21.0, 22.0, 23.0, 22.0, 21.0],
                [18.0, 17.0, 16.0, 17.0, 18.0, 19.0, 18.0, 17.0]
            ]
        ])
    );
}

#[test] // Results verified with the `pad(mode='symmetric')` function from NumPy. (v1.21.4)
fn test_pad_symmetric() {
    let data = simple_data_1d();
    assert_eq!(pad(&data, &[[1, 0]], PadMode::Symmetric), arr1(&[0, 0, 1, 2, 3]));
    assert_eq!(pad(&data, &[[0, 1]], PadMode::Symmetric), arr1(&[0, 1, 2, 3, 3]));
    assert_eq!(pad(&data, &[[1, 1]], PadMode::Symmetric), arr1(&[0, 0, 1, 2, 3, 3]));
    assert_eq!(pad(&data, &[[2, 2]], PadMode::Symmetric), arr1(&[1, 0, 0, 1, 2, 3, 3, 2]));

    let data = simple_data_2d();
    assert_relative_eq!(
        pad(&data, &[[1, 1], [1, 1],], PadMode::Symmetric),
        arr2(&[
            [0.0, 0.0, 1.0, 2.0, 3.0, 3.0],
            [0.0, 0.0, 1.0, 2.0, 3.0, 3.0],
            [4.0, 4.0, 5.0, 6.0, 7.0, 7.0],
            [8.0, 8.0, 9.0, 10.0, 11.0, 11.0],
            [8.0, 8.0, 9.0, 10.0, 11.0, 11.0]
        ])
    );
    assert_relative_eq!(
        pad(&data, &[[1, 1], [2, 2]], PadMode::Symmetric),
        arr2(&[
            [1.0, 0.0, 0.0, 1.0, 2.0, 3.0, 3.0, 2.0],
            [1.0, 0.0, 0.0, 1.0, 2.0, 3.0, 3.0, 2.0],
            [5.0, 4.0, 4.0, 5.0, 6.0, 7.0, 7.0, 6.0],
            [9.0, 8.0, 8.0, 9.0, 10.0, 11.0, 11.0, 10.0],
            [9.0, 8.0, 8.0, 9.0, 10.0, 11.0, 11.0, 10.0]
        ])
    );

    let data = simple_data_3d();
    assert_relative_eq!(
        pad(&data, &[[1, 1], [1, 1], [1, 1]], PadMode::Symmetric),
        arr3(&[
            [
                [0.0, 0.0, 1.0, 2.0, 3.0, 3.0],
                [0.0, 0.0, 1.0, 2.0, 3.0, 3.0],
                [4.0, 4.0, 5.0, 6.0, 7.0, 7.0],
                [8.0, 8.0, 9.0, 10.0, 11.0, 11.0],
                [8.0, 8.0, 9.0, 10.0, 11.0, 11.0]
            ],
            [
                [0.0, 0.0, 1.0, 2.0, 3.0, 3.0],
                [0.0, 0.0, 1.0, 2.0, 3.0, 3.0],
                [4.0, 4.0, 5.0, 6.0, 7.0, 7.0],
                [8.0, 8.0, 9.0, 10.0, 11.0, 11.0],
                [8.0, 8.0, 9.0, 10.0, 11.0, 11.0]
            ],
            [
                [12.0, 12.0, 13.0, 14.0, 15.0, 15.0],
                [12.0, 12.0, 13.0, 14.0, 15.0, 15.0],
                [16.0, 16.0, 17.0, 18.0, 19.0, 19.0],
                [20.0, 20.0, 21.0, 22.0, 23.0, 23.0],
                [20.0, 20.0, 21.0, 22.0, 23.0, 23.0]
            ],
            [
                [12.0, 12.0, 13.0, 14.0, 15.0, 15.0],
                [12.0, 12.0, 13.0, 14.0, 15.0, 15.0],
                [16.0, 16.0, 17.0, 18.0, 19.0, 19.0],
                [20.0, 20.0, 21.0, 22.0, 23.0, 23.0],
                [20.0, 20.0, 21.0, 22.0, 23.0, 23.0]
            ]
        ])
    );
    assert_relative_eq!(
        pad(&data, &[[0, 0], [1, 1], [2, 2]], PadMode::Symmetric),
        arr3(&[
            [
                [1.0, 0.0, 0.0, 1.0, 2.0, 3.0, 3.0, 2.0],
                [1.0, 0.0, 0.0, 1.0, 2.0, 3.0, 3.0, 2.0],
                [5.0, 4.0, 4.0, 5.0, 6.0, 7.0, 7.0, 6.0],
                [9.0, 8.0, 8.0, 9.0, 10.0, 11.0, 11.0, 10.0],
                [9.0, 8.0, 8.0, 9.0, 10.0, 11.0, 11.0, 10.0]
            ],
            [
                [13.0, 12.0, 12.0, 13.0, 14.0, 15.0, 15.0, 14.0],
                [13.0, 12.0, 12.0, 13.0, 14.0, 15.0, 15.0, 14.0],
                [17.0, 16.0, 16.0, 17.0, 18.0, 19.0, 19.0, 18.0],
                [21.0, 20.0, 20.0, 21.0, 22.0, 23.0, 23.0, 22.0],
                [21.0, 20.0, 20.0, 21.0, 22.0, 23.0, 23.0, 22.0]
            ]
        ])
    );
}

#[test] // Results verified with the `pad(mode='wrap')` function from NumPy. (v1.21.4)
fn test_pad_wrap() {
    let data = simple_data_1d();
    assert_eq!(pad(&data, &[[1, 0]], PadMode::Wrap), arr1(&[3, 0, 1, 2, 3]));
    assert_eq!(pad(&data, &[[0, 1]], PadMode::Wrap), arr1(&[0, 1, 2, 3, 0]));
    assert_eq!(pad(&data, &[[1, 1]], PadMode::Wrap), arr1(&[3, 0, 1, 2, 3, 0]));
    assert_eq!(pad(&data, &[[2, 2]], PadMode::Wrap), arr1(&[2, 3, 0, 1, 2, 3, 0, 1]));

    let data = simple_data_2d();
    assert_relative_eq!(
        pad(&data, &[[1, 1], [1, 1],], PadMode::Wrap),
        arr2(&[
            [11.0, 8.0, 9.0, 10.0, 11.0, 8.0],
            [3.0, 0.0, 1.0, 2.0, 3.0, 0.0],
            [7.0, 4.0, 5.0, 6.0, 7.0, 4.0],
            [11.0, 8.0, 9.0, 10.0, 11.0, 8.0],
            [3.0, 0.0, 1.0, 2.0, 3.0, 0.0]
        ])
    );
    assert_relative_eq!(
        pad(&data, &[[1, 1], [2, 2]], PadMode::Wrap),
        arr2(&[
            [10.0, 11.0, 8.0, 9.0, 10.0, 11.0, 8.0, 9.0],
            [2.0, 3.0, 0.0, 1.0, 2.0, 3.0, 0.0, 1.0],
            [6.0, 7.0, 4.0, 5.0, 6.0, 7.0, 4.0, 5.0],
            [10.0, 11.0, 8.0, 9.0, 10.0, 11.0, 8.0, 9.0],
            [2.0, 3.0, 0.0, 1.0, 2.0, 3.0, 0.0, 1.0]
        ])
    );

    let data = simple_data_3d();
    assert_relative_eq!(
        pad(&data, &[[1, 1], [1, 1], [1, 1]], PadMode::Wrap),
        arr3(&[
            [
                [23.0, 20.0, 21.0, 22.0, 23.0, 20.0],
                [15.0, 12.0, 13.0, 14.0, 15.0, 12.0],
                [19.0, 16.0, 17.0, 18.0, 19.0, 16.0],
                [23.0, 20.0, 21.0, 22.0, 23.0, 20.0],
                [15.0, 12.0, 13.0, 14.0, 15.0, 12.0]
            ],
            [
                [11.0, 8.0, 9.0, 10.0, 11.0, 8.0],
                [3.0, 0.0, 1.0, 2.0, 3.0, 0.0],
                [7.0, 4.0, 5.0, 6.0, 7.0, 4.0],
                [11.0, 8.0, 9.0, 10.0, 11.0, 8.0],
                [3.0, 0.0, 1.0, 2.0, 3.0, 0.0]
            ],
            [
                [23.0, 20.0, 21.0, 22.0, 23.0, 20.0],
                [15.0, 12.0, 13.0, 14.0, 15.0, 12.0],
                [19.0, 16.0, 17.0, 18.0, 19.0, 16.0],
                [23.0, 20.0, 21.0, 22.0, 23.0, 20.0],
                [15.0, 12.0, 13.0, 14.0, 15.0, 12.0]
            ],
            [
                [11.0, 8.0, 9.0, 10.0, 11.0, 8.0],
                [3.0, 0.0, 1.0, 2.0, 3.0, 0.0],
                [7.0, 4.0, 5.0, 6.0, 7.0, 4.0],
                [11.0, 8.0, 9.0, 10.0, 11.0, 8.0],
                [3.0, 0.0, 1.0, 2.0, 3.0, 0.0]
            ]
        ])
    );
    assert_relative_eq!(
        pad(&data, &[[0, 0], [1, 1], [2, 2]], PadMode::Wrap),
        arr3(&[
            [
                [10.0, 11.0, 8.0, 9.0, 10.0, 11.0, 8.0, 9.0],
                [2.0, 3.0, 0.0, 1.0, 2.0, 3.0, 0.0, 1.0],
                [6.0, 7.0, 4.0, 5.0, 6.0, 7.0, 4.0, 5.0],
                [10.0, 11.0, 8.0, 9.0, 10.0, 11.0, 8.0, 9.0],
                [2.0, 3.0, 0.0, 1.0, 2.0, 3.0, 0.0, 1.0]
            ],
            [
                [22.0, 23.0, 20.0, 21.0, 22.0, 23.0, 20.0, 21.0],
                [14.0, 15.0, 12.0, 13.0, 14.0, 15.0, 12.0, 13.0],
                [18.0, 19.0, 16.0, 17.0, 18.0, 19.0, 16.0, 17.0],
                [22.0, 23.0, 20.0, 21.0, 22.0, 23.0, 20.0, 21.0],
                [14.0, 15.0, 12.0, 13.0, 14.0, 15.0, 12.0, 13.0]
            ]
        ])
    );
}

#[test] // Results verified with the `pad(mode='median')` function from NumPy. (v1.21.4)
fn test_pad_edge() {
    let data = simple_data_1d();
    assert_eq!(pad(&data, &[[1, 0]], PadMode::Edge), arr1(&[0, 0, 1, 2, 3]));
    assert_eq!(pad(&data, &[[0, 1]], PadMode::Edge), arr1(&[0, 1, 2, 3, 3]));
    assert_eq!(pad(&data, &[[1, 1]], PadMode::Edge), arr1(&[0, 0, 1, 2, 3, 3]));
    assert_eq!(pad(&data, &[[2, 2]], PadMode::Edge), arr1(&[0, 0, 0, 1, 2, 3, 3, 3]));

    let data = simple_data_2d();
    assert_relative_eq!(
        pad(&data, &[[1, 1], [2, 2]], PadMode::Edge),
        arr2(&[
            [0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 3.0, 3.0],
            [0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 3.0, 3.0],
            [4.0, 4.0, 4.0, 5.0, 6.0, 7.0, 7.0, 7.0],
            [8.0, 8.0, 8.0, 9.0, 10.0, 11.0, 11.0, 11.0],
            [8.0, 8.0, 8.0, 9.0, 10.0, 11.0, 11.0, 11.0]
        ])
    );

    let data = simple_data_3d();
    assert_relative_eq!(
        pad(&data.view(), &[[0, 0], [1, 1], [2, 2]], PadMode::Edge),
        arr3(&[
            [
                [0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 3.0, 3.0],
                [0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 3.0, 3.0],
                [4.0, 4.0, 4.0, 5.0, 6.0, 7.0, 7.0, 7.0],
                [8.0, 8.0, 8.0, 9.0, 10.0, 11.0, 11.0, 11.0],
                [8.0, 8.0, 8.0, 9.0, 10.0, 11.0, 11.0, 11.0]
            ],
            [
                [12.0, 12.0, 12.0, 13.0, 14.0, 15.0, 15.0, 15.0],
                [12.0, 12.0, 12.0, 13.0, 14.0, 15.0, 15.0, 15.0],
                [16.0, 16.0, 16.0, 17.0, 18.0, 19.0, 19.0, 19.0],
                [20.0, 20.0, 20.0, 21.0, 22.0, 23.0, 23.0, 23.0],
                [20.0, 20.0, 20.0, 21.0, 22.0, 23.0, 23.0, 23.0]
            ]
        ])
    );
}