Checking equality on array with different layout

[zkrzyzanowski]

Hi!
I refactored some code recently that produced a 2d array from a function. In our tests, we're comparing that result with an expected array for equality

assert_eq!(expected_array, result.some_array)

Looking at the difference, the elements and shape are both identical, the 2 arrays only differ on strides and layout.

The expected array has a layout of layout=Cc, while the changed code has a layout of layout=Ff. Strides are different as well.

Based on this issue, it seems like this is an implementation detail we shouldn't necessarily care about, but how would you recommend we compare for equality of elements here? Is the only way to do an element by element comparison?

Apologies for not having a reproduction of the issue, this is code that's nested pretty deeply in our codebase.

Thank you in advance for the help!

[jturner314]

To clarify, my comment on #1198 was specifically about the text "CFcf" in the debug-formatted string being an implementation detail, not the layout itself. The layout itself can be important and is not just an implementation detail. While the memory layout of an array doesn't affect the results of most methods, it does affect performance (iterating over an array is fastest in memory order) and it does affect the results of a few methods, such as as_slice_memory_order.

To answer your question -- similar to how arithmetic operations work elementwise, comparisons also operate on the corresponding elements of the arrays (i.e. those at the same n-D index), regardless of layout. (PartialEq is implemented using Zip.) Here's an example:

use ndarray::prelude::*;

fn main() {
    let shape = [2, 3];
    let a = Array2::from_shape_fn(shape, |(i, j)| i * 10 + j);
    let b = Array2::from_shape_fn(shape.f(), |(i, j)| i * 10 + j);
    assert!(a.is_standard_layout());
    assert!(b.t().is_standard_layout());
    assert_eq!(a.shape(), b.shape());
    assert_eq!(a, b);
    assert_eq!(
        a,
        array![
            [00, 01, 02,],
            [10, 11, 12,],
        ]
    );
    assert_eq!(
        b,
        array![
            [00, 01, 02,],
            [10, 11, 12,],
        ]
    );
    assert_ne!(
        a,
        array![
            [00, 01, 999999,],
            [10, 11, 12,],
        ]
    );
    assert_ne!(
        a,
        array![
            [10, 11, 12,],
            [00, 01, 02,],
        ]
    );
    println!("done");
}

(Rust Playground)

Array a has C layout, and array b has Fortran layout. They have the same shape and elements; the data is just laid out differently in memory. So, a == b is true.

Do you want to require that the arrays have the same layout, in addition to the same shape and elements? If so, you could do the following:

// Check the strides.
assert_eq!(expected_array.strides(), result.some_array.strides());
// Check the shape and elements.
assert_eq!(expected_array, result.some_array);