Add recursivefill!

Project.toml

@@ -1,7 +1,7 @@
 name = "RecursiveArrayTools"
 uuid = "731186ca-8d62-57ce-b412-fbd966d074cd"
 authors = ["Chris Rackauckas <[email protected]>"]
-version = "2.25.2"
+version = "2.26.0"
 
 [deps]
 Adapt = "79e6a3ab-5dfb-504d-930d-738a2a938a0e"

src/RecursiveArrayTools.jl

@@ -28,7 +28,7 @@ Base.show(io::IO, x::Union{ArrayPartition,AbstractVectorOfArray}) = invoke(show,
 export VectorOfArray, DiffEqArray, AbstractVectorOfArray, AbstractDiffEqArray,
        AllObserved, vecarr_to_arr, vecarr_to_vectors, tuples
 
-export recursivecopy, recursivecopy!, vecvecapply, copyat_or_push!,
+export recursivecopy, recursivecopy!, recursivefill!, vecvecapply, copyat_or_push!,
        vecvec_to_mat, recursive_one, recursive_mean, recursive_bottom_eltype,
        recursive_unitless_bottom_eltype, recursive_unitless_eltype
 

src/utils.jl

@@ -41,6 +41,27 @@ function recursivecopy!(b::AbstractArray{T,N},a::AbstractArray{T2,N}) where {T<:
   return b
 end
 
+function recursivefill!(b::AbstractArray{T,N},a::T2) where {T<:StaticArray,T2<:StaticArray,N}
+  @inbounds for i in eachindex(b)
+    b[i] = copy(a)
+  end
+end
+
+function recursivefill!(b::AbstractArray{T,N},a::T2) where {T<:Enum,T2<:Enum,N}
+  fill!(b,a)
+end
+
+function recursivefill!(b::AbstractArray{T,N},a::T2) where {T<:Number,T2<:Number,N}
+  fill!(b, a)
+end
+
+function recursivefill!(b::AbstractArray{T,N},a) where {T<:AbstractArray,N}
+  @inbounds for i in eachindex(b)
+    recursivefill!(b[i], a)
+  end
+  return b
+end
+
 function vecvec_to_mat(vecvec)
   mat = Matrix{eltype(eltype(vecvec))}(undef, length(vecvec),length(vecvec[1]))
   for i in 1:length(vecvec)

test/utils_test.jl

@@ -2,31 +2,31 @@ using RecursiveArrayTools, StaticArrays
 using Test
 
 t = collect(range(0, stop=10, length=200))
-randomized = VectorOfArray([.01randn(2) for i in 1:10])
-data = convert(Array,randomized)
+randomized = VectorOfArray([0.01randn(2) for i in 1:10])
+data = convert(Array, randomized)
 @test typeof(data) <: Matrix{Float64}
 
 ## Test means
-A = [[1 2; 3 4],[1 3;4 6],[5 6;7 8]]
+A = [[1 2; 3 4], [1 3; 4 6], [5 6; 7 8]]
 @test recursive_mean(A) ≈ [2.33333333 3.666666666
-           4.6666666666 6.0]
+  4.6666666666 6.0]
 
-A = zeros(5,5)
+A = zeros(5, 5)
 @test recursive_unitless_eltype(A) == Float64
 
 using Unitful
-A = zeros(5,5)*1u"kg"
+A = zeros(5, 5) * 1u"kg"
 @test recursive_unitless_eltype(A) == Float64
-AA = [zeros(5,5) for i in 1:5]
+AA = [zeros(5, 5) for i in 1:5]
 @test recursive_unitless_eltype(AA) == Array{Float64,2}
 AofA = [copy(A) for i in 1:5]
 @test recursive_unitless_eltype(AofA) == Array{Float64,2}
-AofSA = [@SVector [2.0,3.0] for i in 1:5]
+AofSA = [@SVector [2.0, 3.0] for i in 1:5]
 @test recursive_unitless_eltype(AofSA) == SVector{2,Float64}
-AofuSA = [@SVector [2.0u"kg",3.0u"kg"] for i in 1:5]
+AofuSA = [@SVector [2.0u"kg", 3.0u"kg"] for i in 1:5]
 @test recursive_unitless_eltype(AofuSA) == SVector{2,Float64}
 
-A = [ArrayPartition(ones(1),ones(1)),]
+A = [ArrayPartition(ones(1), ones(1)),]
 
 function test_recursive_bottom_eltype()
   function test_value(val::Any, expected_type::Type)
@@ -70,3 +70,22 @@ test_recursive_bottom_eltype()
 using RecursiveArrayTools: issymbollike
 @test !issymbollike(1)
 @test issymbollike(:a)
+
+x = zeros(10)
+recursivefill!(x, 1.0)
+@test x == ones(10)
+
+x = [zeros(10), zeros(10)]
+recursivefill!(x, 1.0)
+@test x[1] == ones(10)
+@test x[2] == ones(10)
+
+x = [SVector{10}(zeros(10)), SVector{10}(zeros(10))]
+recursivefill!(x, SVector{10}(ones(10)))
+@test x[1] == SVector{10}(ones(10))
+@test x[2] == SVector{10}(ones(10))
+
+x = [MVector{10}(zeros(10)), MVector{10}(zeros(10))]
+recursivefill!(x, 1.0)
+@test x[1] == MVector{10}(ones(10))
+@test x[2] == MVector{10}(ones(10))