Windowed Slicing As an NDarray Macro?

[GabrielaSNC]

Greetings, everyone.

I am new to Rust and want to draft my own window-slicing macro akin to the ndarrays existing s! Slice macro. My Goal is to return a view of the existing array centered around the provided index of any n-dimensional array and, if possible, pad the returned view with a default padding value for literal edge cases. Although a naive first attempt at drafting this declarative macro. I want to illustrate the concept, and seek guidance on where to go next. In all likelihood, this should be a function and not a macro; that said, I am drafting a series of declarative macros to expand my understanding of Rust's array package.

All constructive feedback is welcome.

macro_rules! ws{
    ($arr:expr, $index:expr, $window_dim:expr, $pad_value:expr) => {{
        let ndim = $arr.ndim();
        // first checks of each window_dim is odd. 
        if $window_dim.iter().any(|&x| x % 2 == 0) {
            panic!("The window dimensions must be odd numbers");
        }
        // Checks the number of dimensions of the input array
        // match the length of the window_dim
        if &ndim != $window_dim.len() {
            panic!("The number of dimensions of the input array must match the length of the window_dim");
        }
        // validates the index Vec of Vec dimensions and the array dimensions
        // match. if not panics. 
        if $index[0].len() != ndim {
            panic!("The number of dimensions of the input array must match the length of the index Vec of Vec");
        }

        // if the array is 1D
        if ndim == 1 {
            // divides the window_dim by 2 to get the index distance from the center
            // of the window. Rounds down to the nearest integer
            let pad = $window_dim[0] / 2;
            let start = $index[0][0] as isize - pad as isize;
            let end = $index[0][0] + pad + 1;
            // does a cursory check if the window ends are within bounds
            if start < 0 || end > $arr.len() as isize {
                return Array::from_elem($window_dim[0], $pad_value);
            }
            let s = $arr.slice(s![start..end]);
            return s;
        } else if ndim == 2 {
            let pad = $window_dim[0] / 2;
            let start_row = $index[0][0] as isize - pad as isize;
            let end_row = $index[0][0] + pad + 1;
            let start_col = $index[0][1] as isize - pad as isize;
            let end_col = $index[0][1] + pad + 1;
            // does a cursory check if the window ends are within bounds
            if start_row < 0 || end_row > $arr.shape()[0] as isize || start_col < 0 || end_col > $arr.shape()[1] as isize {
                return Array::from_elem(($window_dim[0], $window_dim[1]), $pad_value);
            }
            let s = $arr.slice(s![start_row..end_row, start_col..end_col]);
            return s;

        } else if ndim == 3 {
            let pad = $window_dim[0] / 2;
            let start_row = $index[0][0] as isize - pad as isize;
            let end_row = $index[0][0] + pad + 1;
            let start_col = $index[0][1] as isize - pad as isize;
            let end_col = $index[0][1] + pad + 1;
            let start_depth = $index[0][2] as isize - pad as isize;
            let end_depth = $index[0][2] + pad + 1;
            // does a cursory check if the window ends are within bounds
            if start_row < 0 || end_row > $arr.shape()[0] as isize || start_col < 0 || end_col > $arr.shape()[1] as isize || start_depth < 0 || end_depth > $arr.shape()[2] as isize {
                return Array::from_elem(($window_dim[0], $window_dim[1], $window_dim[2]), $pad_value);
            }
            let s = $arr.slice(s![start_row..end_row, start_col..end_col, start_depth..end_depth]);
            return s;
        } else if ndim == 4 {
            let pad = $window_dim[0] / 2;
            let start_row = $index[0][0] as isize - pad as isize;
            let end_row = $index[0][0] + pad + 1;
            let start_col = $index[0][1] as isize - pad as isize;
            let end_col = $index[0][1] + pad + 1;
            let start_depth = $index[0][2] as isize - pad as isize;
            let end_depth = $index[0][2] + pad + 1;
            let start_dim4 = $index[0][3] as isize - pad as isize;
            let end_dim4 = $index[0][3] + pad + 1;
            // does a cursory check if the window ends are within bounds
            if start_row < 0 || end_row > $arr.shape()[0] as isize || start_col < 0 || end_col > $arr.shape()[1] as isize || start_depth < 0 || end_depth > $arr.shape()[2] as isize || start_dim4 < 0 || end_dim4 > $arr.shape()[3] as isize {
                return Array::from_elem(($window_dim[0], $window_dim[1], $window_dim[2], $window_dim[3]), $pad_value);
            }
            let s = $arr.slice(s![start_row..end_row, start_col..end_col, start_depth..end_depth, start_dim4..end_dim4]);
            return s;
        } else if ndim == 5 {
            let pad = $window_dim[0] / 2;
            let start_row = $index[0][0] as isize - pad as isize;
            let end_row = $index[0][0] + pad + 1;
            let start_col = $index[0][1] as isize - pad as isize;
            let end_col = $index[0][1] + pad + 1;
            let start_depth = $index[0][2] as isize - pad as isize;
            let end_depth = $index[0][2] + pad + 1;
            let start_dim4 = $index[0][3] as isize - pad as isize;
            let end_dim4 = $index[0][3] + pad + 1;
            let start_dim5 = $index[0][4] as isize - pad as isize;
            let end_dim5 = $index[0][4] + pad + 1;
            // does a cursory check if the window ends are within bounds
            if start_row < 0 || end_row > $arr.shape()[0] as isize || start_col < 0 || end_col > $arr.shape()[1] as isize || start_depth < 0 || end_depth > $arr.shape()[2] as isize || start_dim4 < 0 || end_dim4 > $arr.shape()[3] as isize || start_dim5 < 0 || end_dim5 > $arr.shape()[4] as isize {
                return Array::from_elem(($window_dim[0], $window_dim[1], $window_dim[2], $window_dim[3], $window_dim[4]), $pad_value);
            }
            let s = $arr.slice(s![start_row..end_row, start_col..end_col, start_depth..end_depth, start_dim4..end_dim4, start_dim5..end_dim5]);
            return s;
        } else {
            panic!("The array dimensions must be 1D, 2D, 3D, 4D or 5D");
        }
    }};
}

[nilgoyette]

I can't help you much with the code, but I do have some comments.

• Writing such a function in Rust is hard (impossible?) because you're returning 2 different types. In your first return, it's an owned array, in the second, it's a view. Afaik, you can't do that in Rust. You can either return owned or view, but not a mix depending on some deep condition. This would be super easy in Python, I know, but Rust in another beast.
  • Moreover, it's surprising for the user (the caller). Sometimes, your function allocates, sometimes not.
• Is your padding code unfinished? return Array::from_elem($window_dim[0], $pad_value); You're supposed to take the input array content and fill the unknowns with pad_value.
  • I'm the owner of ndarray-ndimage, a crate which might be able to help you with padding.