T-Vector{m-element Vector{Float64}} into matrix

New to Julia
, , ,
1

Hi,

in my code I often use function broadcasting and then end up with objects A like T-element Vector{m-element Vector{Float64}}. I was wondering if there is an easy command to convert A into T-by-m or m-by-T matrix.

It’s not hard to find a work-around by creating an empty T-by-m matrix B and then looping through the ‘vector’ A and assigning each row of B an element

B = zeros(T,m)
for t in 1:T
    B[t,:] = A[t]
end

but I was still wondering if there is faster/less wordy way to do this.

Thank you!

2

The pre-allocation + loop is a good solution. But you should change the orientation, since Arrays are column-major, so do B[:, t] = A[t] instead.

You can also shave off a bit of time by not initializing B with zeros, and instead do B = Matrix{Float64}(undef, T, m)

If you want less verbose, you can try

B = reduce(hcat, A)

I suspect it will be slower, but try to benchmark it.

3

Just use stack.

julia> using Compat: stack

julia> v = [rand(5) for _ ∈ 1:3]
3-element Vector{Vector{Float64}}:
 [0.8171909831508164, 0.15661016815437745, 0.2715396576556385, 0.28385016413585673, 0.5190445250315925]
 [0.7812480311360239, 0.5024262604639554, 0.9024872826844329, 0.80961891784007, 0.8617609639038173]
 [0.7349009228629912, 0.29003919828230684, 0.7731877384653875, 0.36098642491910127, 0.39708957802744305]

julia> stack(v)
5×3 Matrix{Float64}:
 0.817191  0.781248  0.734901
 0.15661   0.502426  0.290039
 0.27154   0.902487  0.773188
 0.28385   0.809619  0.360986
 0.519045  0.861761  0.39709

julia> stack(v, dims=1)
3×5 Matrix{Float64}:
 0.817191  0.15661   0.27154   0.28385   0.519045
 0.781248  0.502426  0.902487  0.809619  0.861761
 0.734901  0.290039  0.773188  0.360986  0.39709
3 Likes
4

How’s this?

A = [1, 2, 3]
B = [x for x ∈ A, j=1:5]

flip x and j iterations to flip dimensions.

5

The question is also, why do you end up with a nested array in the first place?
From the top of my head, I could think of two obvious ways

  1. You are using eachslice or something like that
  2. You broadcast a function returning an array

In such cases, there are several libraries like SplitApplyCombine.jl or JuliennedArrays.jl which can split into and recombine from nested arrays, i.e., just like stack already mentioned. Further, I had experimented with a small library JJ.jl which allows to apply functions to smaller dimensional parts of an array and automatically recollects all results into an array:

julia> A = [1 2 3; 4 5 6]
2×3 Matrix{Int64}:
 1  2  3
 4  5  6

julia> foo(x) = x .+ [-1, 1]
foo (generic function with 1 method)

julia> foo.(A)
2×3 Matrix{Vector{Int64}}:
 [0, 2]  [1, 3]  [2, 4]
 [3, 5]  [4, 6]  [5, 7]

julia> using JJ

julia> rank"foo 0"(A)  # Same as stack(foo.(A))
2×2×3 Align{Int64, 3} with eltype Int64:
[:, :, 1] =
 0  3
 2  5

[:, :, 2] =
 1  4
 3  6

[:, :, 3] =
 2  5
 4  7

julia> rank"foo 1"(A)  # same as stack(foo.(eachslice(A; dims=2)))
2×3 Align{Int64, 2} with eltype Int64:
 0  1  2
 5  6  7
1 Like