feature request: Consider adding a strides method to np.dtype

See here.

It would do something like this:

def strides_from_dtype(dtype):
    shape = list(dtype.shape)

    # Make the strides for an array with an itemsize of 1 in C-order.
    tmp_strides = shape[::-1]
    tmp_strides[1:] = list(np.cumprod(tmp_strides[:-1]))
    tmp_strides[0] = 1

    # Adjust it for the real itemsize.
    tmp_strides = dtype.base.itemsize * np.array(tmp_strides)

    # Convert it to a tuple, reversing it back for proper C-order.
    return tuple(tmp_strides[::-1])

This works, but it seems inefficient:

strides = np.zeros((), dtype=dtype).strides

[eric-wieser]

@njsmith: I see where you’re coming from, but I think we should explicitly support this:

• I think it’s in our interest to preserve strides / offsets in some_real_array[empty_slice], to allow them to be used similarly to C++ iterators / pointers
• Given the above, I can’t see a reason to special case empty-array creation vs empty array views

Regarding my post above - here’s an implementation of some syntactic sugar to solve your problem https://gist.github.com/eric-wieser/d8790dede1c9311c5670018ee1cee83a

With this, the offset and strides for a['time']['subtime'][2] can be gotten with just

field_info(a.dtype)['time']['subtime'][2].offset

[eric-wieser]

Thanks for the inspiration, @njsmith: here’s a neat solution I came up with

def address_of(x):
    assert isinstance(x, np.ndarray)  # make sure we don't get a scalar here, which will not be a view
    return x.__array_interface__['data'][0]

dt = np.dtype([('time', [('subtime', np.int32, (30,20))], 200), ('value', np.float32, (10,2))])
a = np.empty((0,), dtype=dt)  # constant size, independent of the array size

offset = address_of(x['time'][...,100]['subtime'][...,10,1]) - address_of(a)
# 240804