Julia：将数组向量转换为任意维数的数组-Julia:ConvertingVectorofArraystoArrayforArbitraryDimensions

9  

This is the sort of thing that Julia's custom array infrastructure excels at. I think the simplest solution here is to actually make a special array type that does this transformation for you:

这是Julia的定制阵列基础设施擅长的事情。我认为这里最简单的解决方案是实际制作一个特殊的数组类型,为您进行这种转换:

immutable StackedArray{T,N,A} <: AbstractArray{T,N}
    data::A # A <: AbstractVector{<:AbstractArray{T,N-1}}
    dims::NTuple{N,Int}
end
function StackedArray(vec::AbstractVector)
    @assert all(size(vec[1]) == size(v) for v in vec)
    StackedArray(vec, (length(vec), size(vec[1])...))
end
StackedArray{T, N}(vec::AbstractVector{T}, dims::NTuple{N}) = StackedArray{eltype(T),N,typeof(vec)}(vec, dims)
Base.size(S::StackedArray) = S.dims
@inline function Base.getindex{T,N}(S::StackedArray{T,N}, I::Vararg{Int,N})
    @boundscheck checkbounds(S, I...)
    S.data[I[1]][Base.tail(I)...]
end

Now just wrap your vector in a StackedArray and it'll behave like an N+1 dimensional array. This could be expanded and made more featureful (it could similarly support setindex! or even push!ing arrays to concatenate natively), but I think that it's sufficient to solve your problem. By simply wrapping uFull in a StackedArray you get an object that acts like an Array{T, N+1}. Make a copy, and you get exactly a dense Array{T, N+1} without ever needing to write a for loop yourself.

现在只需将您的矢量包装在StackedArray中,它的行为就像一个N + 1维数组。这可以扩展并使其更具特色(它可以类似地支持setindex!甚至推送数组本地连接),但我认为它足以解决您的问题。通过简单地将uFull包装在StackedArray中,您将获得一个类似于Array {T,N + 1}的对象。制作一个副本,你就可以获得一个密集的数组{T,N + 1}而无需自己编写for循环。

julia> S = StackedArray(uFull)
10001x4x4 StackedArray{Int64,3,Array{Array{Int64,2},1}}:
[:, :, 1] =
 1  1  1  5
 1  1  1  5
 1  1  1  5
…

julia> squeeze(S[1:1, :, :], 1) == u
true

julia> copy(S) # returns a dense Array{T,N}
10001x4x4 Array{Int64,3}:
[:, :, 1] =
 1  1  1  5
 1  1  1  5
…

Finally, I'll just note that there's another solution here: you could introduce the custom array type sooner, and make a GrowableArray that internally stores its elements as a linear Vector{T}, but allows pushing entire columns or arrays directly.

最后,我要注意这里还有另一个解决方案:你可以更快地引入自定义数组类型,并使GrowableArray在内部将其元素存储为线性Vector {T},但允许直接推送整个列或数组。

5  

Matt B.'s answer is great, because it "simulates" an array without actually having to create or store it. When you can use this solution, it's likely to be your best choice.

Matt B.的答案很棒,因为它“模拟”了一个数组,而不必实际创建或存储它。当您可以使用此解决方案时,它可能是您的最佳选择。

However, there might be circumstances where you need to create a concatenated array (e.g., if you're passing this to some C code which requires contiguous memory). In that case you can just call cat, which is generic (it can handle arbitrary dimensions).

但是,在某些情况下您可能需要创建一个连接数组(例如,如果您将其传递给某些需要连续内存的C代码)。在这种情况下,你可以只调用cat,它是通用的(它可以处理任意维度)。

For example:

u =  [1 2 3 4
      1 3 3 4
      1 5 6 3
      5 2 3 1]
uFull = Vector{typeof(u)}(0)
push!(uFull,u)
for i = 1:10000
  push!(uFull,u)
end
ucat = cat(ndims(eltype(uFull))+1, uFull)

I took the liberty of making one important change to your code: uFull = Vector{typeof(u)}(0) because it ensures that the objects stored in the Vector container have concrete type. Array{Int} is actually an abstract type, because you'd need to specify the dimensionality too (Array{Int,2}).

我冒昧地对你的代码做了一个重要的改动:uFull = Vector {typeof(u)}(0)因为它确保了Vector容器中存储的对象具有具体的类型。 Array {Int}实际上是一个抽象类型,因为您还需要指定维度(Array {Int,2})。