Fix stride(A, i) for 0-dim inputs

[N5N3]

This PR recover the orignal behavior of stride for Union{DenseArray,StridedReshapedArray,StridedReinterpretArray}.
Besides, stride(a::AbstractArray{<:Any, 0}, k) now always return 1 if k >= 1 and strides is defined.

Test added. (Close #44087)

[mkitti]

Do we prefer

ndims(A) == 0 ? 1 : sum(st .* size(A))

over

sum(st .* size(A); init = 1)

?

[N5N3]

I have no idea. For me we can return any value if k > ndims(A).
But since Strided.jl hardcoded a stride test.
I guess we'd better keep the return as before if possible?

[JeffBezanson]

This seems like a very low-level function to be calling broadcast and reduce. Should probably be a loop.

[mkitti]

I suggest restoring this function:

function _stride(a, i)
    if i > ndims(a)
        return length(a)
    end
    s = 1
    for n = 1:(i-1)
        s *= size(a, n)
    end
    return s
end

julia/base/reinterpretarray.jl

Lines 162 to 171 in dd0c14b

	function _stride(a, i)
	if i > ndims(a)
	return length(a)
	end
	s = 1
	for n = 1:(i-1)
	s *= size(a, n)
	end
	return s
	end

[N5N3]

The orginal version doesn't thrown a error for stride(a, -1).
On 1.7, we have

julia> stride([], -1)
1
julia> stride(view([1],1:1), -1)
ERROR: BoundsError: attempt to access Tuple{Int64} at index [-1]
Stacktrace:
 [1] getindex
   @ .\tuple.jl:29 [inlined]
 [2] stride(V::SubArray{Int64, 1, Vector{Int64}, Tuple{UnitRange{Int64}}, true}, d::Int64)
   @ Base .\subarray.jl:358
 [3] top-level scope
   @ REPL[2]:1

I think it's meaningful to keep error messages' consistency. The easist way is to follow the implement in general fallback.
(And they should have no performance difference)

[mkitti]

@JeffBezanson , @N5N3 . I'm confused. I get a distinct result with this new implementation.

Julia 1.7.2:

julia> stride(zeros(5,3,2),1)
1

julia> stride(zeros(5,3,2),2)
5

julia> stride(zeros(5,3,2),3)
15

julia> stride(zeros(5,3,2),4)
30

This function:

julia> function new_stride(A::AbstractArray, k::Integer)
           st = strides(A)
           k ≤ ndims(A) && return st[k]
           ndims(A) == 0 && return 1
           sz = size(A)
           s = st[1] * sz[1]
           for i in 2:ndims(A)
               s += st[i] * sz[i]
           end
           return s
       end
new_stride (generic function with 1 method)

julia> new_stride(zeros(5,3,2),1)
1

julia> new_stride(zeros(5,3,2),2)
5

julia> new_stride(zeros(5,3,2),3)
15

julia> new_stride(zeros(5,3,2),4)
50

Why are we summing?

julia> strides(A) .* size(A)
(5, 15, 30)

julia> strides(A) .* size(A) |> sum
50

[N5N3]

We only do sum for non-dense array. see #35929 (comment) for more details.

[musm]

Upon reflection here I still do have a slight preference for return sum(st .* size(A)) here simply because using length alone is a code smell in strides computations — it just looks wrong. Indeed, it makes it clearer that we need to call strides in this branch (like Tim noted above). But as a style thing, I'll leave the final decision to you.

I'm not sure I follow the logic either for k > ndims(A). Sounds like the preference to sum is to avoid using length ?

[N5N3]

I guess yes. Although it's correctness is also fragile as stride could < 0.