如何在 Julia 中从行/列向量构造矩阵

Question

给定一个产生单列的函数/表达式，如何在 Julia 中从这些列构建矩阵？我尝试了以下（简化示例）：

column(j) = [j, j, j]      # for example
my_matrix = Float64[column(j)[i] for i in 1:3, j in 1:4]

==> 3x4 Array{Float64,2}:
 1.0  2.0  3.0  4.0
 1.0  2.0  3.0  4.0
 1.0  2.0  3.0  4.0

结果是正确的，但这不是我想要的，因为列向量表达式被不必要地评估（每行一次）。

我也尝试过这种替代方法：

[column(j) for j in 1:4]

==> 4-element Array{Array{Float64,1},1}:
 [1.0,1.0,1.0]
 [2.0,2.0,2.0]
 [3.0,3.0,3.0]
 [4.0,4.0,4.0]

但我没有办法将其转换或重塑成我想要的形式（二维矩阵而不是数组数组）。

如何在 Julia 中实现这一点？

Answer 1

你试过hcat吗？：

julia> column(j) = [j, j ,j]
column (generic function with 1 method)

julia> my_matrix  = hcat([column(j) for j=1:4]...)
3x4 Array{Int64,2}:
 1  2  3  4
 1  2  3  4
 1  2  3  4

见hcat in Julia docs

Answer 2

但我没有办法将其转换或重塑成我想要的形式（二维矩阵而不是数组数组）。

您可以通过对列c的列向量的扁平化版本进行整形来获得矩阵：

julia> column(j) = [j, j, j]
column (generic function with 1 method)

julia> c = [column(j) for j in 1:4]
4-element Vector{Vector{Int64}}:
 [1, 1, 1]
 [2, 2, 2]
 [3, 3, 3]
 [4, 4, 4]

julia> v = collect(Iterators.flatten(c))
12-element Vector{Int64}:
 1
 1
 1
 2
 2
 2
 3
 3
 3
 4
 4
 4

julia> m = reshape(v, 3, 4)
3×4 Matrix{Int64}:
 1  2  3  4
 1  2  3  4
 1  2  3  4

接受的答案建议的替代hcat(c...) 也可以，但正如评论所指出的，这不适用于大量列。 实际上，如果c 是n 列的向量，那么hcat(c...) 将编译带有n 参数的方法。这首先意味着如果您的代码对不同数量的列执行此操作，那么您每次都需要编译一个新方法。其次，编译参数过多的方法会导致栈内存溢出。

因此，当您不需要单行解决方案时（例如，像上面结合 flatten 和 reshape 的解决方案），在我看来大多数 Julia 用户都这样做：

m = Matrix{Int}(undef, 3, 4)
for j in 1:4
    m[:, j] = column(j)
end

编辑 @Przemyslaw 提出了一个更好的解决方案：https://stackoverflow.com/a/68976092/1189815

Answer 3

查看答案@Benoit 实际上使用reduce(hcat, c) 更快：

julia> c = [[j,j,j] for j in 1:4]
4-element Vector{Vector{Int64}}:
 [1, 1, 1]
 [2, 2, 2]
 [3, 3, 3]
 [4, 4, 4]


julia> @btime reshape(collect(Iterators.flatten($c)), 3, 4)
  232.791 ns (6 allocations: 448 bytes)
3×4 Matrix{Int64}:
 1  2  3  4
 1  2  3  4
 1  2  3  4

julia> @btime reduce(hcat, $c)
  70.825 ns (1 allocation: 176 bytes)
3×4 Matrix{Int64}:
 1  2  3  4
 1  2  3  4
 1  2  3  4