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

Author: jonniedie

.github/workflows/TagBot.yml

@@ -1,11 +1,15 @@
 name: TagBot
 on:
-  schedule:
-    - cron: 0 0 * * *
+  issue_comment:
+    types:
+      - created
+  workflow_dispatch:
 jobs:
   TagBot:
+    if: github.event_name == 'workflow_dispatch' || github.actor == 'JuliaTagBot'
     runs-on: ubuntu-latest
     steps:
       - uses: JuliaRegistries/TagBot@v1
         with:
-          token: ${{ secrets.GITHUB_TOKEN }}
+          token: ${{ secrets.GITHUB_TOKEN }}
+          ssh: ${{ secrets.DOCUMENTER_KEY }}

.github/workflows/ci.yml

@@ -16,6 +16,8 @@ jobs:
       matrix:
         version:
           - '1.2'
+          - '1.3'
+          - '1.4'
           - '1.5'
           - '1' # Leave this line unchanged. '1' will automatically expand to the latest stable 1.x release of Julia.
           - 'nightly'

.gitignore

@@ -10,6 +10,6 @@ research/
 /examples/wip
 /examples/ignore
 /examples/.ipynb_checkpoints
-.vscode/settings.json
+.vscode
 /issue_debug
 Manifest.toml

Manifest.toml

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

Project.toml

@@ -3,7 +3,7 @@ using Documenter, ComponentArrays
 makedocs(;
     modules=[ComponentArrays],
     format=Documenter.HTML(
-        canonical = "https://jonniedie.github.io/ComponentArrays.jl/stable",
+        canonical="https://jonniedie.github.io/ComponentArrays.jl/stable",
         ),
     pages=[
         "Home" => "index.md",
@@ -19,6 +19,7 @@ makedocs(;
     sitename="ComponentArrays.jl",
     authors="Jonnie Diegelman",
     assets=String[],
+    doctest=:fix,
 )
 
 deploydocs(;

docs/make.jl

@@ -9,8 +9,26 @@ Base.axes(x::ComponentArray) = axes(getdata(x))
 
 Base.reinterpret(::Type{T}, x::ComponentArray, args...) where T = ComponentArray(reinterpret(T, getdata(x), args...), getaxes(x))
 
-Base.hcat(x::CV...) where {CV<:ComponentVector} = ComponentArray(reduce(hcat, getdata.(x)), getaxes(x[1])[1], FlatAxis())
+# Cats
+# TODO: Make this a little less copy-pastey
+function Base.hcat(x::AbstractComponentVecOrMat, y::AbstractComponentVecOrMat)
+    ax_x, ax_y = second_axis.((x,y))
+    if reduce((accum, key) -> accum || (key in keys(ax_x)), keys(ax_y); init=false) || getaxes(x)[1] != getaxes(y)[1]
+        return hcat(getdata(x), getdata(y))
+    else
+        data_x, data_y = getdata.((x, y))
+        ax_y = reindex(ax_y, size(x,2))
+        idxmap_x, idxmap_y = indexmap.((ax_x, ax_y))
+        axs = getaxes(x)
+        return ComponentArray(hcat(data_x, data_y), axs[1], Axis((;idxmap_x..., idxmap_y...)), axs[3:end]...)
+    end
+end
 
+second_axis(ca::AbstractComponentVecOrMat) = getaxes(ca)[2]
+second_axis(::ComponentVector) = FlatAxis()
+
+# Are all these methods necessary?
+# TODO: See what we can reduce down to without getting ambiguity errors
 Base.vcat(x::ComponentVector, y::AbstractVector) = vcat(getdata(x), y)
 Base.vcat(x::AbstractVector, y::ComponentVector) = vcat(x, getdata(y))
 function Base.vcat(x::ComponentVector, y::ComponentVector)
@@ -24,11 +42,33 @@ function Base.vcat(x::ComponentVector, y::ComponentVector)
         return ComponentArray(vcat(data_x, data_y), Axis((;idxmap_x..., idxmap_y...)))
     end
 end
+function Base.vcat(x::AbstractComponentVecOrMat, y::AbstractComponentVecOrMat)
+    ax_x, ax_y = getindex.(getaxes.((x, y)), 1)
+    if reduce((accum, key) -> accum || (key in keys(ax_x)), keys(ax_y); init=false) || getaxes(x)[2:end] != getaxes(y)[2:end]
+        return vcat(getdata(x), getdata(y))
+    else
+        data_x, data_y = getdata.((x, y))
+        ax_y = reindex(ax_y, size(x,1))
+        idxmap_x, idxmap_y = indexmap.((ax_x, ax_y))
+        return ComponentArray(vcat(data_x, data_y), Axis((;idxmap_x..., idxmap_y...)), getaxes(x)[2:end]...)
+    end
+end
 Base.vcat(x::CV...) where {CV<:AdjOrTransComponentArray} = ComponentArray(reduce(vcat, map(y->getdata(y.parent)', x)), getaxes(x[1]))
-Base.vcat(x::ComponentVector...) = reduce(vcat, x)
 Base.vcat(x::ComponentVector, args...) = vcat(getdata(x), getdata.(args)...)
 Base.vcat(x::ComponentVector, args::Vararg{AbstractVector{T}, N}) where {T,N} = vcat(getdata(x), getdata.(args)...)
 
+function Base.hvcat(row_lengths::Tuple{Vararg{Int}}, xs::AbstractComponentVecOrMat...)
+    i = 1
+    idxs = UnitRange{Int}[]
+    for row_length in row_lengths
+        i_last = i + row_length - 1
+        push!(idxs, i:i_last)
+        i = i_last + 1
+    end
+    rows = [reduce(hcat, xs[idx]) for idx in idxs]
+    return vcat(rows...)
+end
+
 function Base.permutedims(x::ComponentArray, dims)
     axs = getaxes(x)
     return ComponentArray(permutedims(getdata(x), dims), map(i->axs[i], dims)...)
@@ -59,14 +99,14 @@ Base.@propagate_inbounds function Base.getindex(x::ComponentArray, idx::FlatOrCo
     return ComponentArray(getdata(x)[idx...], axs...)
 end
 Base.@propagate_inbounds Base.getindex(x::ComponentArray, ::Colon) = getdata(x)[:]
-@inline Base.getindex(x::ComponentArray, ::Colon...) = x
-Base.@propagate_inbounds Base.getindex(x::ComponentArray, idx...) = getindex(x, toval.(idx)...)
+Base.@propagate_inbounds Base.getindex(x::ComponentArray, ::Colon...) = x
+@inline Base.getindex(x::ComponentArray, idx...) = getindex(x, toval.(idx)...)
 @inline Base.getindex(x::ComponentArray, idx::Val...) = _getindex(x, idx...)
 
 # Set ComponentArray index
-@inline Base.setindex!(x::ComponentArray, v, idx::FlatIdx...) = setindex!(getdata(x), v, idx...)
+Base.@propagate_inbounds Base.setindex!(x::ComponentArray, v, idx::FlatOrColonIdx...) = setindex!(getdata(x), v, idx...)
 Base.@propagate_inbounds Base.setindex!(x::ComponentArray, v, ::Colon) = setindex!(getdata(x), v, :)
-Base.@propagate_inbounds Base.setindex!(x::ComponentArray, v, idx...) = setindex!(x, v, toval.(idx)...)
+@inline Base.setindex!(x::ComponentArray, v, idx...) = setindex!(x, v, toval.(idx)...)
 @inline Base.setindex!(x::ComponentArray, v, idx::Val...) = _setindex!(x, v, idx...)
 
 # Explicitly view
@@ -108,6 +148,56 @@ ArrayInterface.lu_instance(jac_prototype::ComponentArray) = ArrayInterface.lu_in
 
 ArrayInterface.parent_type(::Type{ComponentArray{T,N,A,Axes}}) where {T,N,A,Axes} = A
 
+for f in [*, \, /]
+    op = nameof(f)
+    @eval begin
+        function Base.$op(A::ComponentVecOrMat, B::ComponentMatrix)
+            C = $op(getdata(A), getdata(B))
+            ax1 = getaxes(A)[1]
+            ax2 = getaxes(B)[2]
+            return ComponentArray(C, (ax1, ax2))
+        end
+        function Base.$op(A::ComponentVecOrMat, b::ComponentVector)
+            c = $op(getdata(A), getdata(b))
+            ax1 = getaxes(A)[1]
+            return ComponentArray(c, ax1)
+        end
+        function Base.$op(Aᵀ::ComponentMatrix{T}, B::AdjOrTransComponentVecOrMat{T}) where {T}
+            Cᵀ = $op(getdata(Aᵀ), getdata(B))
+            ax1 = getaxes(Aᵀ)[1]
+            ax2 = getaxes(B)[2]
+            return ComponentArray(Cᵀ, ax1, ax2)
+        end
+    end
+    for (adjfun, AdjType) in zip([adjoint, transpose], [Adjoint, Transpose])
+        adj = nameof(adjfun)
+        Adj = nameof(AdjType)
+        @eval begin
+            function Base.$op(aᵀ::$Adj{T,<:ComponentVector}, B::ComponentMatrix) where {T}
+                cᵀ = parent($op(getdata(aᵀ), getdata(B)))
+                ax2 = getaxes(B)[2]
+                return $adj(ComponentArray(cᵀ, ax2))
+            end
+            function Base.$op(Aᵀ::$Adj{T,<:ComponentMatrix}, B::AdjOrTransComponentVecOrMat) where {T}
+                Cᵀ = $op(getdata(Aᵀ), getdata(B))
+                ax1 = getaxes(Aᵀ)[1]
+                ax2 = getaxes(B)[2]
+                return ComponentArray(Cᵀ, ax1, ax2)
+            end
+            function Base.$op(Aᵀ::$Adj{T,<:ComponentMatrix}, B::ComponentMatrix{T}) where {T}
+                Cᵀ = $op(getdata(Aᵀ), getdata(B))
+                ax1 = getaxes(Aᵀ)[1]
+                ax2 = getaxes(B)[2]
+                return ComponentArray(Cᵀ, ax1, ax2)
+            end
+            function Base.$op(Aᵀ::$Adj{T,<:ComponentMatrix}, b::ComponentVector) where {T}
+                cᵀ = $op(getdata(Aᵀ), getdata(b))
+                ax1 = getaxes(Aᵀ)[1]
+                return ComponentArray(cᵀ, ax1)
+            end
+        end
+    end
+end
 
 
 # While there are some cases where these were faster, it is going to be almost impossible to

src/array_interface.jl

@@ -4,13 +4,56 @@ abstract type AbstractAxis{IdxMap} end
 @inline indexmap(::Type{<:AbstractAxis{IdxMap}}) where IdxMap = IdxMap
 
 
-struct FlatAxis <: AbstractAxis{NamedTuple()} end
+# struct FlatAxis <: AbstractAxis{NamedTuple()} end
 
 struct NullAxis <: AbstractAxis{nothing} end
+const VarAxes = Tuple{Vararg{<:AbstractAxis}}
 
-const NullorFlatAxis = Union{NullAxis, FlatAxis}
 
-const VarAxes = Tuple{Vararg{<:AbstractAxis}}
+"""
+    ax = Axis(nt::NamedTuple)
+
+Gives named component access for `ComponentArray`s.
+# Examples
+
+```
+julia> using ComponentArrays
+
+julia> ax = Axis((a = 1, b = ViewAxis(2:7, PartitionedAxis(2, (a = 1, b = 2))), c = ViewAxis(8:10, (a = 1, b = 2:3))));
+
+julia> A = [100, 4, 1.3, 1, 1, 4.4, 0.4, 2, 1, 45];
+
+julia> ca = ComponentArray(A, ax)
+ComponentVector{Float64}(a = 100.0, b = [(a = 4.0, b = 1.3), (a = 1.0, b = 1.0), (a = 4.4, b = 0.4)], c = (a = 2.0, b = [1.0, 45.0]))
+
+julia> ca.a
+100.0
+
+julia> ca.b
+3-element LazyArray{ComponentVector{Float64,SubArray...}}:
+ ComponentVector{Float64,SubArray...}(a = 4.0, b = 1.3)
+ ComponentVector{Float64,SubArray...}(a = 1.0, b = 1.0)
+ ComponentVector{Float64,SubArray...}(a = 4.4, b = 0.4)
+
+julia> ca.c
+ComponentVector{Float64,SubArray...}(a = 2.0, b = [1.0, 45.0])
+
+julia> ca.c.b
+2-element view(::Vector{Float64}, 9:10) with eltype Float64:
+  1.0
+ 45.0
+```
+"""
+struct Axis{IdxMap} <: AbstractAxis{IdxMap} end
+@inline Axis(IdxMap::NamedTuple) = Axis{IdxMap}()
+Axis(;kwargs...) = Axis((;kwargs...))
+function Axis(symbols::Union{AbstractVector{Symbol}, NTuple{N,Symbol}}) where {N}
+    return Axis((;(symbols .=> eachindex(symbols))...))
+end
+Axis(symbols::Symbol...) = Axis(symbols)
+
+const FlatAxis = Axis{NamedTuple()}
+const NullorFlatAxis = Union{NullAxis, FlatAxis}
 
 
 
@@ -81,49 +124,11 @@ viewindex(::Type{<:ViewAxis{Inds,IdxMap}}) where {Inds,IdxMap} = Inds
 viewindex(i) = i
 
 
-
-"""
-    ax = Axis(nt::NamedTuple)
-
-Gives named component access for `ComponentArray`s.
-# Examples
-
-```jldoctest
-julia> using ComponentArrays
-
-julia> ax = Axis((a = 1, b = ViewAxis(2:7, PartitionedAxis(2, (a = 1, b = 2))), c = ViewAxis(8:10, (a = 1, b = 2:3))));
-
-julia> A = [100, 4, 1.3, 1, 1, 4.4, 0.4, 2, 1, 45];
-
-julia> ca = ComponentArray(A, ax)
-ComponentVector{Float64}(a = 100.0, b = [(a = 4.0, b = 1.3), (a = 1.0, b = 1.0), (a = 4.4, b = 0.4)], c = (a = 2.0, b = [1.0, 45.0]))
-
-julia> ca.a
-100.0
-
-julia> ca.b
-3-element LazyArray{ComponentVector{Float64,SubArray...},1}:
- ComponentVector{Float64,SubArray...}(a = 4.0, b = 1.3)
- ComponentVector{Float64,SubArray...}(a = 1.0, b = 1.0)
- ComponentVector{Float64,SubArray...}(a = 4.4, b = 0.4)
-
-julia> ca.c
-ComponentVector{Float64,SubArray...}(a = 2.0, b = [1.0, 45.0])
-
-julia> ca.c.b
-2-element view(::Array{Float64,1}, 9:10) with eltype Float64:
-  1.0
- 45.0
-```
-"""
-struct Axis{IdxMap} <: AbstractAxis{IdxMap} end
-@inline Axis(IdxMap::NamedTuple) = Axis{IdxMap}()
-Axis(;kwargs...) = Axis((;kwargs...))
-
 Axis(ax::AbstractAxis) = ax
 Axis(ax::PartitionedAxis) = ax.ax
 Axis(ax::ViewAxis) = ax.ax
 
+# Get rid of this
 Axis(::Number) = NullAxis()
 Axis(::NamedTuple{()}) = FlatAxis()
 Axis(x) = FlatAxis()
@@ -137,6 +142,9 @@ Base.merge(axs::Axis...) = Axis(merge(indexmap.(axs)...))
 
 Base.lastindex(ax::AbstractAxis) = last(viewindex(last(indexmap(ax))))
 
+Base.keys(ax::AbstractAxis) = keys(indexmap(ax))
+
 reindex(i, offset) = i .+ offset
+reindex(ax::FlatAxis, _) = ax
 reindex(ax::Axis, offset) = Axis(map(x->reindex(x, offset), indexmap(ax)))
 reindex(ax::ViewAxis, offset) = ViewAxis(viewindex(ax) .+ offset, indexmap(ax))

src/axis.jl

@@ -69,7 +69,7 @@ function Base.similar(bc::BC.Broadcasted{<:CAStyle{<:BC.Unknown, Axes, N}}, T::T
 end
 
 
-BC.broadcasted(f, x::ComponentArray) = ComponentArray(map(f, getdata(x)), getaxes(x))
+# BC.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.
@@ -104,7 +104,8 @@ function fill_flat(Ax1, Ax2, N1, N2)
         N = N1
         ax1, ax2 = Ax1, Ax2
     end
-    Ax = promote.(getaxes(ax1), getaxes(ax2)) |> typeof
+    # Ax = Base.promote_typeof(getaxes(ax1), getaxes(ax2))
+    Ax = broadcast_promote_typeof(getaxes(ax1), getaxes(ax2))
     return Ax, N
 end
 fill_flat(Ax::Type{<:VarAxes}, N) = fill_flat(getaxes(Ax), N) |> typeof