Merge branch 'master' of https://github.com/jonniedie/ComponentArrays.jl

Author: jonniedie

NEWS.md

@@ -1,6 +1,18 @@
 # ComponentArrays.jl NEWS
 Notes on new features (minor releases). For more details on bugfixes and non-feature-adding changes (patch releases), check out the [releases page](https://github.com/jonniedie/ComponentArrays.jl/releases).
 
+### v0.9.0
+- Construct `ComponentArray`s from `Dict`s!
+```julia
+julia> d = Dict(:a=>rand(3), :b=>rand(2,2))
+Dict{Symbol, Array{Float64, N} where N} with 2 entries:
+  :a => [0.996693, 0.148683, 0.203083]
+  :b => [0.68759 0.41585; 0.900591 0.377475]
+
+julia> ComponentArray(d)
+ComponentVector{Float64}(a = [0.9966932920820444, 0.14868304847436709, 0.20308284992079573], b = [0.6875902095731583 0.415850281435181; 0.9005909643364229 0.3774747843717925])
+```
+
 ### v0.8.0
 - Generated `valkeys` function for fast iteration over `ComponentVector` subcomponents!
 ```julia

Project.toml

@@ -1,7 +1,7 @@
 name = "ComponentArrays"
 uuid = "b0b7db55-cfe3-40fc-9ded-d10e2dbeff66"
 authors = ["Jonnie Diegelman <47193959+jonniedie@users.noreply.github.com>"]
-version = "0.8.20"
+version = "0.9.0"
 
 [deps]
 ArrayInterface = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9"

src/broadcasting.jl

@@ -69,8 +69,13 @@ function Base.similar(bc::BC.Broadcasted{<:CAStyle{<:BC.Unknown, Axes, N}}, T::T
 end
 
 
-Base.Broadcast.broadcasted(f, x::ComponentArray) = ComponentArray(map(f, x), getaxes(x))
+Base.Broadcast.broadcasted(f, x::ComponentArray) = ComponentArray(map(f, getdata(x)), getaxes(x))
 
+# Need a special case here because `map` doesn't follow same rules as normal broadcasting. To be safe and avoid ambiguities,
+# we'll just handle the case where everything is a ComponentArray. Else it falls back to a plain Array output.
+function Base.map(f, xs::ComponentArray{<:Any, <:Any, <:Any, Axes}...) where Axes
+    return ComponentArray(map(f, getdata.(xs)...), getaxes(Axes))
+end
 
 # function Base.copy(bc::BC.Broadcasted{<:CAStyle{InnerStyle, Axes, N}}) where {InnerStyle, Axes,  N}
 #     return ComponentArray{Axes}(Base.copy(BC.broadcasted(bc.f, map(getdata, bc.args)...)))

src/componentarray.jl

@@ -57,9 +57,10 @@ function ComponentArray(data, ax::AbstractAxis...)
     return LazyArray(ComponentArray(x, axs) for x in part_data)
 end
 
-# Entry from NamedTuple or kwargs
+# Entry from NamedTuple, Dict, or kwargs
 ComponentArray{T}(nt::NamedTuple) where T = ComponentArray(make_carray_args(T, nt)...)
 ComponentArray(nt::NamedTuple) = ComponentArray(make_carray_args(nt)...)
+ComponentArray(d::AbstractDict) = ComponentArray(NamedTuple{Tuple(keys(d))}(values(d)))
 ComponentArray{T}(;kwargs...) where T = ComponentArray{T}((;kwargs...))
 ComponentArray(;kwargs...) = ComponentArray((;kwargs...))
 

src/if_required/chainrulescore.jl

@@ -6,8 +6,8 @@ using ChainRulesCore: NO_FIELDS
 #     setproperty!(zero_x, s, Δ)
 #     return getproperty(x, s), zero_x
 # end
-ChainRulesCore.rrule(::typeof(getproperty), x::ComponentArray, s::Symbol) = ChainRulesCore.rrule(getproperty, x, Val(s))
-function ChainRulesCore.rrule(::typeof(getproperty), x::ComponentArray, ::Val{s}) where s
+ChainRulesCore.rrule(::typeof(getproperty), x::ComponentArray, ::Val{s}) where s = ChainRulesCore.rrule(getproperty, x, s)
+function ChainRulesCore.rrule(::typeof(getproperty), x::ComponentArray, s::Symbol)
     function getproperty_adjoint(Δ)
         zero_x = zero(x)
         setproperty!(zero_x, s, Δ)
@@ -17,12 +17,8 @@ function ChainRulesCore.rrule(::typeof(getproperty), x::ComponentArray, ::Val{s}
     return getproperty(x, s), getproperty_adjoint
 end
 
-# ChainRulesCore.frule(::typeof(getdata), x::ComponentArray) = getdata(x), Δ->ComponentArray(Δ, getaxes(x))
-ChainRulesCore.rrule(::typeof(getdata), x::ComponentArray) = getdata(x), Δ->(NO_FIELDS, ComponentArray(Δ, getaxes(x)))
-
-ChainRulesCore.rrule(::typeof(getaxes), x::ComponentArray) = getaxes(x), Δ->(NO_FIELDS, ComponentArray(getdata(x), Δ))
+ChainRulesCore.rrule(::typeof(getdata), x::ComponentArray) = getdata(x), Δ->ComponentArray(Δ, getaxes(x))
 
 ChainRulesCore.rrule(::Type{ComponentArray}, data, axes) = ComponentArray(data, axes), Δ->(NO_FIELDS, getdata(Δ), getaxes(Δ))
 
-ChainRulesCore.rrule(::Type{Axis}, nt) = Axis(nt), Δ->(NO_FIELDS, ComponentArrays.indexmap(Δ))
-ChainRulesCore.rrule(::Type{Axis}; kwargs...) = Axis(; kwargs...), Δ->(NO_FIELDS, (; ComponentArrays.indexmap(Δ)...))
+ChainRulesCore.rrule(::Type{ComponentArray}, data, axes) = ComponentArray(data, axes), Δ->(getdata(Δ), getaxes(Δ))

src/similar_convert_copy.jl

@@ -3,15 +3,21 @@
 Base.similar(x::ComponentArray) = ComponentArray(similar(getdata(x)), getaxes(x)...)
 Base.similar(x::ComponentArray, ::Type{T}) where T = ComponentArray(similar(getdata(x), T), getaxes(x)...)
 Base.similar(x::ComponentArray, ::Type{T}, ax::Tuple{Vararg{Int64,N}}) where {T,N} = similar(x, T, ax...)
-Base.similar(x::ComponentArray, ::Type{T}, ax::Union{Integer, Base.OneTo}...) where T =
-    similar(getdata(x), T, ax...)
+function Base.similar(x::ComponentArray, ::Type{T}, ax::Union{Integer, Base.OneTo}...) where T
+    A = similar(getdata(x), T, ax...)
+    if size(getdata(x)) == size(A)
+        return ComponentArray(A, getaxes(x))
+    else
+        return A
+    end
+end
+
 ## TODO: write length method for AbstractAxis so we can do this?
     # function Base.similar(::Type{CA}) where CA<:ComponentArray{T,N,A,Axes} where {T,N,A,Axes}
 #     axs = getaxes(CA)
 #     return ComponentArray(similar(A, length.(axs)...), axs...)
 # end
 
-
 Base.zero(x::ComponentArray) = zero.(x)
 
 ## FIXME: waiting on similar(::Type{<:ComponentArray})

test/runtests.jl

@@ -56,6 +56,12 @@ end
     @test typeof(ComponentArray{Float32}(undef, (ax,))) == typeof(ca_Float32)
     @test typeof(ComponentArray{MVector{10,Float64}}(undef, (ax,))) == typeof(ca_MVector)
 
+    # Entry from Dict
+    dict1 = Dict(:a=>rand(5), :b=>rand(5,5))
+    dict2 = Dict(:a=>3, :b=>dict1)
+    @test ComponentArray(dict1) isa ComponentArray
+    @test ComponentArray(dict2).b isa ComponentArray
+
     @test ca == ComponentVector(a=100, b=[4, 1.3], c=(a=(a=1, b=[1.0, 4.4]), b=[0.4, 2, 1, 45]))
     @test cmat == ComponentMatrix(a .* a', ax, ax)
     @test_throws DimensionMismatch ComponentVector(sq_mat, ax)
@@ -277,6 +283,12 @@ end
     @test getaxes(x1mat + xmat) == (getaxes(x1)[1], FlatAxis())
     @test getaxes(x1mat + xmat') == (FlatAxis(), getaxes(x1)[1])
 
+    @test map(sqrt, ca) isa ComponentArray
+    @test map(+, ca, sqrt.(ca)) isa ComponentArray
+    @test map(+, sqrt.(ca), Float32.(ca), ca) isa ComponentArray
+    @test map(+, ca, getdata(ca)) isa Array
+    @test map(+, ca, ComponentArray(v=getdata(ca))) isa Array
+
     x1 .+= x2
     @test getdata(x1) == 2getdata(x2)