Merge pull request #307 from AayushSabharwal/as/utils

fix: add utils methods for AbstractVectorOfArray, fix method overwriting on 1.10

Author: ChrisRackauckas

src/array_partition.jl

@@ -423,7 +423,7 @@ ArrayInterface.zeromatrix(A::ArrayPartition) = ArrayInterface.zeromatrix(Vector(
 
 function __get_subtypes_in_module(mod, supertype; include_supertype = true, all=false, except=[])
     return filter([getproperty(mod, name) for name in names(mod; all) if !in(name, except)]) do value
-            return value isa Type && (value <: supertype) && (include_supertype || value != supertype) && !in(value, except)
+            return value != Union{} && value isa Type && (value <: supertype) && (include_supertype || value != supertype) && !in(value, except)
         end
 end
 

src/utils.jl

@@ -1,6 +1,6 @@
 """
 ```julia
-recursivecopy(b::AbstractArray{T, N}, a::AbstractArray{T, N})
+recursivecopy(a::Union{AbstractArray{T, N}, AbstractVectorOfArray{T,N}})
 ```
 
 A recursive `copy` function. Acts like a `deepcopy` on arrays of arrays, but
@@ -26,6 +26,12 @@ function recursivecopy(a::AbstractArray{T, N}) where {T <: AbstractArray, N}
     end
 end
 
+function recursivecopy(a::AbstractVectorOfArray)
+    b = copy(a)
+    b.u = recursivecopy.(a.u)
+    return b
+end
+
 """
 ```julia
 recursivecopy!(b::AbstractArray{T, N}, a::AbstractArray{T, N})
@@ -36,37 +42,39 @@ like `copy!` on arrays of scalars.
 """
 function recursivecopy! end
 
-function recursivecopy!(b::AbstractArray{T, N},
-    a::AbstractArray{T2, N}) where {T <: StaticArraysCore.StaticArray,
-    T2 <: StaticArraysCore.StaticArray,
-    N}
-    @inbounds for i in eachindex(a)
-        # TODO: Check for `setindex!`` and use `copy!(b[i],a[i])` or `b[i] = a[i]`, see #19
-        b[i] = copy(a[i])
+for type in [AbstractArray, AbstractVectorOfArray]
+    @eval function recursivecopy!(b::$type{T, N},
+        a::$type{T2, N}) where {T <: StaticArraysCore.StaticArray,
+        T2 <: StaticArraysCore.StaticArray,
+        N}
+        @inbounds for i in eachindex(a)
+            # TODO: Check for `setindex!`` and use `copy!(b[i],a[i])` or `b[i] = a[i]`, see #19
+            b[i] = copy(a[i])
+        end
     end
-end
 
-function recursivecopy!(b::AbstractArray{T, N},
-    a::AbstractArray{T2, N}) where {T <: Enum, T2 <: Enum, N}
-    copyto!(b, a)
-end
+    @eval function recursivecopy!(b::$type{T, N},
+        a::$type{T2, N}) where {T <: Enum, T2 <: Enum, N}
+        copyto!(b, a)
+    end
 
-function recursivecopy!(b::AbstractArray{T, N},
-    a::AbstractArray{T2, N}) where {T <: Number, T2 <: Number, N}
-    copyto!(b, a)
-end
+    @eval function recursivecopy!(b::$type{T, N},
+        a::$type{T2, N}) where {T <: Number, T2 <: Number, N}
+        copyto!(b, a)
+    end
 
-function recursivecopy!(b::AbstractArray{T, N},
-    a::AbstractArray{T2, N}) where {T <: AbstractArray,
-    T2 <: AbstractArray, N}
-    if ArrayInterface.ismutable(T)
-        @inbounds for i in eachindex(b, a)
-            recursivecopy!(b[i], a[i])
+    @eval function recursivecopy!(b::$type{T, N},
+        a::$type{T2, N}) where {T <: Union{AbstractArray, AbstractVectorOfArray},
+        T2 <: Union{AbstractArray, AbstractVectorOfArray}, N}
+        if ArrayInterface.ismutable(T)
+            @inbounds for i in eachindex(b, a)
+                recursivecopy!(b[i], a[i])
+            end
+        else
+            copyto!(b, a)
         end
-    else
-        copyto!(b, a)
+        return b
     end
-    return b
 end
 
 """
@@ -110,32 +118,36 @@ function recursivefill!(bs::AbstractVectorOfArray{T, N},
     end
 end
 
-function recursivefill!(b::AbstractArray{T, N}, a::T2) where {T <: Enum, T2 <: Enum, N}
-    fill!(b, a)
-end
+for type in [AbstractArray, AbstractVectorOfArray]
+    @eval function recursivefill!(b::$type{T, N}, a::T2) where {T <: Enum, T2 <: Enum, N}
+        fill!(b, a)
+    end
 
-function recursivefill!(b::AbstractArray{T, N},
-    a::T2) where {T <: Union{Number, Bool}, T2 <: Union{Number, Bool}, N
-}
-    fill!(b, a)
-end
+    @eval function recursivefill!(b::$type{T, N},
+        a::T2) where {T <: Union{Number, Bool}, T2 <: Union{Number, Bool}, N
+    }
+        fill!(b, a)
+    end
 
-function recursivefill!(b::AbstractArray{T, N}, a) where {T <: StaticArraysCore.MArray, N}
-    @inbounds for i in eachindex(b)
-        if isassigned(b, i)
-            recursivefill!(b[i], a)
-        else
-            b[i] = zero(eltype(b))
-            recursivefill!(b[i], a)
+    for type2 in [Any, StaticArraysCore.StaticArray]
+        @eval function recursivefill!(b::$type{T, N}, a::$type2) where {T <: StaticArraysCore.MArray, N}
+            @inbounds for i in eachindex(b)
+                if isassigned(b, i)
+                    recursivefill!(b[i], a)
+                else
+                    b[i] = zero(eltype(b))
+                    recursivefill!(b[i], a)
+                end
+            end
         end
     end
-end
-
-function recursivefill!(b::AbstractArray{T, N}, a) where {T <: AbstractArray, N}
-    @inbounds for i in eachindex(b)
-        recursivefill!(b[i], a)
+    
+    @eval function recursivefill!(b::$type{T, N}, a) where {T <: AbstractArray, N}
+        @inbounds for i in eachindex(b)
+            recursivefill!(b[i], a)
+        end
+        return b
     end
-    return b
 end
 
 # Deprecated

src/vector_of_array.jl

@@ -488,6 +488,9 @@ end
 function Base.checkbounds(VA::AbstractVectorOfArray, idx...)
     checkbounds(Bool, VA, idx...) || throw(BoundsError(VA, idx))
 end
+function Base.copyto!(dest::AbstractVectorOfArray{T,N}, src::AbstractVectorOfArray{T,N}) where {T,N}
+    copyto!.(dest.u, src.u)
+end
 
 # Operations
 function Base.isapprox(A::AbstractVectorOfArray,
@@ -544,7 +547,6 @@ end
 @inline function Base.similar(VA::VectorOfArray, ::Type{T} = eltype(VA)) where {T}
     VectorOfArray([similar(VA[:, i], T) for i in eachindex(VA.u)])
 end
-recursivecopy(VA::VectorOfArray) = VectorOfArray(copy.(VA.u))
 
 # fill!
 # For DiffEqArray it ignores ts and fills only u

test/qa.jl

@@ -3,7 +3,7 @@ using RecursiveArrayTools, Aqua
     Aqua.find_persistent_tasks_deps(RecursiveArrayTools)
     ambs = Aqua.detect_ambiguities(RecursiveArrayTools; recursive = true)
     @warn "Number of method ambiguities: $(length(ambs))"
-    @test length(ambs) <= 2
+    @test length(ambs) <= 1
     Aqua.test_deps_compat(RecursiveArrayTools)
     Aqua.test_piracies(RecursiveArrayTools)
     Aqua.test_project_extras(RecursiveArrayTools)

test/utils_test.jl

@@ -113,3 +113,13 @@ recursivefill!(x, true)
     recursivefill!(y_voa, ones(Vec3))
     @test all(y_voa[:, n] == fill(ones(Vec3), n) for n in 1:4)
 end
+
+@testset "VectorOfArray recursivecopy!" begin
+    u1 = VectorOfArray([fill(2, MVector{2, Float64}), ones(MVector{2, Float64})])
+    u2 = VectorOfArray([fill(4, MVector{2, Float64}), 2 .* ones(MVector{2, Float64})])
+    recursivecopy!(u1,u2)
+    @test u1.u[1] == [4.0,4.0]
+    @test u1.u[2] == [2.0,2.0]
+    @test u1.u[1] isa MVector
+    @test u1.u[2] isa MVector
+end