Multiplication by non-square matrix should drop labels

[marius311]

On 0.10.7 I get:

julia> rand(2,3) * ComponentArray(x=[1,2,3])
2-element ComponentVector{Float64} with axis Axis(x = 1:3,):
 3.0820225302525293
 3.921995265502881

julia> [rand(2,3) * ComponentArray(x=[1,2,3])]
1-element Vector{ComponentVector{Float64, Vector{Float64}, Tuple{Axis{(x = 1:3,)}}}}:
Error showing value of type Vector{ComponentVector{Float64, Vector{Float64}, Tuple{Axis{(x = 1:3,)}}}}:
ERROR: BoundsError: attempt to access 2-element Vector{Float64} at index [1:3]

When you multipy a ComponentArray by a rectangular matrix, you've changed the dimensionality so it doesn't make sense to preserve the labels. Additionally, you end up with an object whose labels and actual length are inconsistent, which can lead to e.g. the printing error in the second line.

Afaict the solutions are 1) drop the labels for non-square matrices, although a side-effect is that by definition Matrix * ComponentVector is no longer type stable, or 2) drop the labels for both square and non-square matrices, in which case it can be type stable, and if the user wants labels they need to label the matrix explicilty and hence do ComponentMatrix * ComponentVector. Not sure which is the better choice.

[jonniedie]

Oh, this is a definitely a bug. Even for square matrices this is wrong. For example, if the matrix was a ComponentMatrix, the behavior works as expected (i.e. it only takes the labels from the first axis of the matrix):

julia> x = ComponentArray(x=1:3);

julia> y = ComponentArray(y=4:6);

julia> z = ComponentArray(z=7:9);

julia> yz = y * z'
3×3 ComponentMatrix{Int64} with axes Axis(y = 1:3,) × Axis(z = 1:3,)
 28  32  36
 35  40  45
 42  48  54

julia> yz*x
ComponentVector{Int64}(y = [200, 250, 300])

This shouldn't be happening:

julia> getdata(yz)*x
ComponentVector{Int64}(x = [200, 250, 300])

The labels should come from the first axis of the matrix here and when that matrix doesn't have labels on the first axis (or, in this case, any axis), the result should be a plain Vector.

I'll have to see what's going on in the broadcasting machinery that's causing this issue.

[jonniedie]

Ah, here's the issue. The default matrix by vector multiplication in LinearAlgebra creates the output vector like this:

similar(x, TS, axes(A,1))

That calls this method in ComponentArrays:

function Base.similar(x::ComponentArray{T1,N,A,Ax}, ::Type{T}, dims::NTuple{N,Int}) where {T,T1,N,A,Ax}
    arr = similar(getdata(x), T, dims)
    return ComponentArray(arr, getaxes(x))
end

The reason this doesn't happen with A::ComponentMatrix * x::ComponentVector is because that case is handled explicitly here. There are basically two options to go from here:

1. Handle all multiplication and left/right division by AbstractMatrix and AbstractVector explicitly like this. I really don't want to do this, though. This is how things were set up in the past and it led to method ambiguity hell. In essence, ComponentArrays will no longer be able to multiply with other nonstandard arrays (like StaticArrays) without explicit overloads. It's pretty unmaintainable.
2. Make Base.axes return the Axis of the ComponentArray (which I've already been meaning to do for a while). I'm pretty convinced this is the correct way to handle it. I don't remember why this didn't work when I tried it before, but I'm sure I can work though it.