Assume parent array has same strides (#192)

* Assume parent array has same strides

* Try to fix reinterpret failures

* Tests no longer broken

Co-authored-by: Chris Elrod <[email protected]>

Author: Tokazama

Project.toml

@@ -1,6 +1,6 @@
 name = "ArrayInterface"
 uuid = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9"
-version = "3.1.24"
+version = "3.1.25"
 
 [deps]
 IfElse = "615f187c-cbe4-4ef1-ba3b-2fcf58d6d173"

src/stridelayout.jl

@@ -502,8 +502,10 @@ while still producing correct behavior when using valid cartesian indices, such
 strides(A::StrideIndex) = getfield(A, :strides)
 @inline strides(A::Vector{<:Any}) = (StaticInt(1),)
 @inline strides(A::Array{<:Any,N}) where {N} = (StaticInt(1), Base.tail(Base.strides(A))...)
-function strides(x)
-    if defines_strides(x)
+@inline function strides(x::X) where {X}
+    if !(parent_type(X) <: X)
+        return strides(parent(x))
+    elseif defines_strides(X)
         return size_to_strides(size(x), One())
     else
         return Base.strides(x)
@@ -519,11 +521,19 @@ function strides(A::ReshapedArray{T,N,P}) where {T, N, P<:AbstractVector}
         return Base.strides(A)
     end
 end
+function strides(A::ReshapedArray{T,N,P}) where {T, N, P}
+    if defines_strides(A)
+        return size_to_strides(size(A), static(1))
+    else
+        return Base.strides(A)
+    end
+end
+
 
 @inline bmap(f::F, t::Tuple{}, x::Number) where {F} = ()
 @inline bmap(f::F, t::Tuple{T}, x::Number) where {F, T} = (f(first(t),x), )
 @inline bmap(f::F, t::Tuple, x::Number) where {F} = (f(first(t),x), bmap(f, Base.tail(t), x)...)
-if VERSION ≥ v"1.6.0-DEV.1581"
+@static if VERSION ≥ v"1.6.0-DEV.1581"
   # from `reinterpret(reshape, ...)`
   @inline function strides(A::Base.ReinterpretArray{R, N, T, B, true}) where {R,N,T,B}
     P = strides(parent(A))
@@ -541,7 +551,6 @@ if VERSION ≥ v"1.6.0-DEV.1581"
       (One(), bmap(*, P, StaticInt(sizeof(T)) ÷ StaticInt(sizeof(R)))...)
     end
   end
-
   # plain `reinterpret(...)`
   @inline function strides(A::Base.ReinterpretArray{R, N, T, B, false}) where {R,N,T,B}
     P = strides(parent(A))
@@ -553,6 +562,18 @@ if VERSION ≥ v"1.6.0-DEV.1581"
       (first(P), bmap(*, Base.tail(P), StaticInt(sizeof(T)) ÷ StaticInt(sizeof(R)))...)
     end
   end
+else
+  # plain `reinterpret(...)`
+  @inline function strides(A::Base.ReinterpretArray{R, N, T}) where {R,N,T}
+    P = strides(parent(A))
+    if sizeof(R) == sizeof(T)
+      P
+    elseif sizeof(R) > sizeof(T)
+      (first(P), bmap(÷, Base.tail(P), StaticInt(sizeof(R)) ÷ StaticInt(sizeof(T)))...)
+    else # sizeof(R) < sizeof(T)
+      (first(P), bmap(*, Base.tail(P), StaticInt(sizeof(T)) ÷ StaticInt(sizeof(R)))...)
+    end
+  end
 end
 #@inline strides(A) = _strides(A, Base.strides(A), contiguous_axis(A))
 

test/runtests.jl

@@ -767,7 +767,7 @@ end
 end
 
 @testset "Reinterpreted reshaped views" begin
-    u_base = randn(1, 4, 4, 5)
+    u_base = randn(1, 4, 4, 5);
     u_vectors = reshape(reinterpret(SVector{1, eltype(u_base)}, u_base),
                         Base.tail(size(u_base))...)
     u_view = view(u_vectors, 2, :, 3)
@@ -778,13 +778,8 @@ end
     @test @inferred(ArrayInterface.strides(u_base)) == (StaticInt(1), 1, 4, 16)
     @test @inferred(ArrayInterface.strides(u_vectors)) == (StaticInt(1), 4, 16)
     @test @inferred(ArrayInterface.strides(u_view)) == (4,)
-    if VERSION ≥ v"1.6.0-DEV.1581"
-        @test @inferred(ArrayInterface.strides(u_view_reinterpreted)) == (4,)
-        @test @inferred(ArrayInterface.strides(u_view_reshaped)) == (4, 4)
-    else
-        @test_broken @inferred(ArrayInterface.strides(u_view_reinterpreted)) == (4,)
-        @test_broken @inferred(ArrayInterface.strides(u_view_reshaped)) == (4, 4)
-    end
+    @test @inferred(ArrayInterface.strides(u_view_reinterpreted)) == (4,)
+    @test @inferred(ArrayInterface.strides(u_view_reshaped)) == (4, 4)
 end
 
 @test ArrayInterface.can_avx(ArrayInterface.can_avx) == false