Update ArrayInterface compatibility to v7 (#61)

Author: mateuszbaran

Project.toml

@@ -1,7 +1,7 @@
 name = "HybridArrays"
 uuid = "1baab800-613f-4b0a-84e4-9cd3431bfbb9"
 authors = ["Mateusz Baran <[email protected]>"]
-version = "0.4.14"
+version = "0.4.15"
 
 [deps]
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
@@ -20,7 +20,8 @@ EllipsisNotation = "da5c29d0-fa7d-589e-88eb-ea29b0a81949"
 ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 Static = "aedffcd0-7271-4cad-89d0-dc628f76c6d3"
+StaticArrayInterface = "0d7ed370-da01-4f52-bd93-41d350b8b718"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [targets]
-test = ["Test", "Random", "ArrayInterface", "EllipsisNotation", "ForwardDiff", "Static"]
+test = ["Test", "Random", "ArrayInterface", "EllipsisNotation", "ForwardDiff", "Static", "StaticArrayInterface"]

src/HybridArrays.jl

@@ -184,6 +184,9 @@ function __init__()
     @require ArrayInterface="4fba245c-0d91-5ea0-9b3e-6abc04ee57a9" begin
         include("array_interface_compat.jl")
     end
+    @require StaticArrayInterface="0d7ed370-da01-4f52-bd93-41d350b8b718" begin
+        include("static_array_interface_compat.jl")
+    end
 end
 
 end # module

src/abstractarray.jl

@@ -5,15 +5,15 @@ Base.dataids(sa::HybridArray) = Base.dataids(parent(sa))
 
 @inline Base.elsize(sa::HybridArray) = Base.elsize(parent(sa))
 
-@inline size(sa::HybridArray{S,T,N,N}) where {S,T,N} = size(parent(sa))
+@inline size(sa::HybridArray{S,T,N,N}) where {S<:Tuple,T,N} = size(parent(sa))
 
 @inline length(sa::HybridArray) = length(parent(sa))
 
-@inline strides(sa::HybridArray{S,T,N,N}) where {S,T,N} = strides(parent(sa))
+@inline strides(sa::HybridArray{S,T,N,N}) where {S<:Tuple,T,N} = strides(parent(sa))
 
 @inline pointer(sa::HybridArray) = pointer(parent(sa))
 
-@generated function _sized_abstract_array_axes(::Type{S}, ax::Tuple) where S<:Tuple
+@generated function _sized_abstract_array_axes(::Type{S}, ax::Tuple) where {S<:Tuple}
     exprs = Any[]
     map(enumerate(S.parameters)) do (i, si)
         if isa(si, Dynamic)
@@ -25,18 +25,18 @@ Base.dataids(sa::HybridArray) = Base.dataids(parent(sa))
     return Expr(:tuple, exprs...)
 end
 
-function axes(sa::HybridArray{S}) where S
+function axes(sa::HybridArray{S}) where {S<:Tuple}
     ax = axes(parent(sa))
     return _sized_abstract_array_axes(S, ax)
 end
 
 
-function promote_rule(::Type{<:HybridArray{S,T,N,M,TDataA}}, ::Type{<:HybridArray{S,U,N,M,TDataB}}) where {S,T,U,N,M,TDataA,TDataB}
+function promote_rule(::Type{<:HybridArray{S,T,N,M,TDataA}}, ::Type{<:HybridArray{S,U,N,M,TDataB}}) where {S<:Tuple,T,U,N,M,TDataA,TDataB}
     TU = promote_type(T,U)
     HybridArray{S,TU,N,M,promote_type(TDataA, TDataB)::Type{<:AbstractArray{TU}}}
 end
 
-@inline copy(a::HybridArray{S, T, N, M}) where {S, T, N, M} = begin
+@inline copy(a::HybridArray{S, T, N, M}) where {S<:Tuple, T, N, M} = begin
     parentcopy = copy(parent(a))
     HybridArray{S, T, N, M, typeof(parentcopy)}(parentcopy)
 end

src/array_interface_compat.jl

@@ -14,49 +14,3 @@ end
 function ArrayInterface.restructure(x::HybridArray{S}, y) where {S}
     return HybridArray{S}(reshape(convert(Array, y), size(x)...))
 end
-
-function ArrayInterface.strides(x::HybridArray)
-    return ArrayInterface.strides(parent(x))
-end
-
-@generated function ArrayInterface.strides(x::HybridArray{S,T,N,N,Array{T,N}}) where {S,T,N}
-    collected_strides = []
-    i = 1
-    for (argnum, Sarg) in enumerate(S.parameters)
-        if i > 0
-            push!(collected_strides, ArrayInterface.StaticInt(i))
-        else
-            push!(collected_strides, :(datastrides[$argnum]))
-        end
-        if Sarg isa Integer
-            i *= Sarg
-        else
-            i = -1
-        end
-    end
-    return quote
-        datastrides = strides(parent(x))
-        return tuple($(collected_strides...))
-    end
-end
-
-@generated function ArrayInterface.size(x::HybridArray{S}) where {S}
-    collected_sizes = []
-    for (argnum, Sarg) in enumerate(S.parameters)
-        if Sarg isa Integer
-            push!(collected_sizes, ArrayInterface.StaticInt(Sarg))
-        else
-            push!(collected_sizes, :(datasize[$argnum]))
-        end
-    end
-    return quote
-        datasize = ArrayInterface.size(parent(x))
-        return tuple($(collected_sizes...))
-    end
-end
-
-ArrayInterface.contiguous_axis(::Type{HybridArray{S,T,N,N,TData}}) where {S,T,N,TData} = ArrayInterface.contiguous_axis(TData)
-ArrayInterface.contiguous_batch_size(::Type{HybridArray{S,T,N,N,TData}}) where {S,T,N,TData} = ArrayInterface.contiguous_batch_size(TData)
-ArrayInterface.stride_rank(::Type{HybridArray{S,T,N,N,TData}}) where {S,T,N,TData} = ArrayInterface.stride_rank(TData)
-
-ArrayInterface.dense_dims(x::HybridArray) = ArrayInterface.dense_dims(x.data)

src/static_array_interface_compat.jl

@@ -0,0 +1,45 @@
+function StaticArrayInterface.strides(x::HybridArray)
+    return StaticArrayInterface.strides(parent(x))
+end
+
+@generated function StaticArrayInterface.strides(x::HybridArray{S,T,N,N,Array{T,N}}) where {S<:Tuple,T,N}
+    collected_strides = []
+    i = 1
+    for (argnum, Sarg) in enumerate(S.parameters)
+        if i > 0
+            push!(collected_strides, StaticArrayInterface.StaticInt(i))
+        else
+            push!(collected_strides, :(datastrides[$argnum]))
+        end
+        if Sarg isa Integer
+            i *= Sarg
+        else
+            i = -1
+        end
+    end
+    return quote
+        datastrides = strides(parent(x))
+        return tuple($(collected_strides...))
+    end
+end
+
+@generated function StaticArrayInterface.size(x::HybridArray{S}) where {S}
+    collected_sizes = []
+    for (argnum, Sarg) in enumerate(S.parameters)
+        if Sarg isa Integer
+            push!(collected_sizes, StaticArrayInterface.StaticInt(Sarg))
+        else
+            push!(collected_sizes, :(datasize[$argnum]))
+        end
+    end
+    return quote
+        datasize = StaticArrayInterface.size(parent(x))
+        return tuple($(collected_sizes...))
+    end
+end
+
+StaticArrayInterface.contiguous_axis(::Type{HybridArray{S,T,N,N,TData}}) where {S,T,N,TData} = StaticArrayInterface.contiguous_axis(TData)
+StaticArrayInterface.contiguous_batch_size(::Type{HybridArray{S,T,N,N,TData}}) where {S,T,N,TData} = StaticArrayInterface.contiguous_batch_size(TData)
+StaticArrayInterface.stride_rank(::Type{HybridArray{S,T,N,N,TData}}) where {S,T,N,TData} = StaticArrayInterface.stride_rank(TData)
+
+StaticArrayInterface.dense_dims(x::HybridArray) = StaticArrayInterface.dense_dims(x.data)

test/array_interface_compat.jl

@@ -1,7 +1,5 @@
 
 using HybridArrays, ArrayInterface, Test, StaticArrays
-using ArrayInterface: StaticInt
-using Static
 
 @testset "ArrayInterface compatibility" begin
     M = HybridMatrix{2, StaticArrays.Dynamic()}([1 2; 4 5])
@@ -11,17 +9,4 @@ using Static
     @test ArrayInterface.parent_type(M) === Matrix{Int}
     @test ArrayInterface.restructure(M, [2, 4, 6, 8]) == HybridMatrix{2, StaticArrays.Dynamic()}([2 6; 4 8])
     @test isa(ArrayInterface.restructure(M, [2, 4, 6, 8]), HybridMatrix{2, StaticArrays.Dynamic()})
-
-    M2 = HybridArray{Tuple{2, 3, StaticArrays.Dynamic(), StaticArrays.Dynamic()}}(randn(2, 3, 5, 7))
-    @test (@inferred ArrayInterface.strides(M2)) === (StaticInt(1), StaticInt(2), StaticInt(6), 30)
-    @test (@inferred ArrayInterface.strides(MV)) === (2, 30)
-    @test (@inferred ArrayInterface.size(M2)) === (StaticInt(2), StaticInt(3), 5, 7)
-
-    @test ArrayInterface.contiguous_axis(typeof(M2)) === ArrayInterface.contiguous_axis(typeof(parent(M2)))
-    @test ArrayInterface.contiguous_batch_size(typeof(M2)) === ArrayInterface.contiguous_batch_size(typeof(parent(M2)))
-    @test ArrayInterface.stride_rank(typeof(M2)) === ArrayInterface.stride_rank(typeof(parent(M2)))
-    @test ArrayInterface.contiguous_axis(typeof(M')) === ArrayInterface.contiguous_axis(typeof(parent(M)'))
-    @test ArrayInterface.contiguous_batch_size(typeof(M')) === ArrayInterface.contiguous_batch_size(typeof(parent(M)'))
-    @test ArrayInterface.stride_rank(typeof(M')) === ArrayInterface.stride_rank(typeof(parent(M)'))
-    @test ArrayInterface.dense_dims(M) === (static(true), static(true))
 end

test/runtests.jl

@@ -162,7 +162,7 @@ include("broadcast.jl")
 include("linalg.jl")
 include("ssubarray.jl")
 include("nonstandard_indices.jl")
-if VERSION >= v"1.2"
-    include("array_interface_compat.jl")
-end
+
+include("array_interface_compat.jl")
+include("static_array_interface_compat.jl")
 include("forwarddiff.jl")

test/static_array_interface_compat.jl

@@ -0,0 +1,19 @@
+
+using HybridArrays, StaticArrayInterface, Test, StaticArrays
+using StaticArrayInterface: StaticInt
+
+@testset "StaticArrayInterface compatibility" begin
+    M = HybridMatrix{2, StaticArrays.Dynamic()}([1 2; 4 5])
+    MV = HybridMatrix{3, StaticArrays.Dynamic()}(view(randn(10, 10), 1:2:5, 1:3:12))
+
+    M2 = HybridArray{Tuple{2, 3, StaticArrays.Dynamic(), StaticArrays.Dynamic()}}(randn(2, 3, 5, 7))
+    @test (@inferred StaticArrayInterface.strides(M2)) === (StaticInt(1), StaticInt(2), StaticInt(6), 30)
+    @test (@inferred StaticArrayInterface.strides(MV)) === (2, 30)
+
+    @test StaticArrayInterface.contiguous_axis(typeof(M2)) === StaticArrayInterface.contiguous_axis(typeof(parent(M2)))
+    @test StaticArrayInterface.contiguous_batch_size(typeof(M2)) === StaticArrayInterface.contiguous_batch_size(typeof(parent(M2)))
+    @test StaticArrayInterface.stride_rank(typeof(M2)) === StaticArrayInterface.stride_rank(typeof(parent(M2)))
+    @test StaticArrayInterface.contiguous_axis(typeof(M')) === StaticArrayInterface.contiguous_axis(typeof(parent(M)'))
+    @test StaticArrayInterface.contiguous_batch_size(typeof(M')) === StaticArrayInterface.contiguous_batch_size(typeof(parent(M)'))
+    @test StaticArrayInterface.stride_rank(typeof(M')) === StaticArrayInterface.stride_rank(typeof(parent(M)'))
+end