Как да конвертирате между различни видове многоизмерни масиви в Julia

Джулия работи в колонен стил, така че основният вектор е колонен вектор. За да преобразувате вектор на колона във вектор на ред, използвайте permutedims(colvec). За да преобразувате вектор на ред във вектор на колона, използвайте permutedims(rowvec).

julia> colvec = [1, 2, 3]
3-element Array{Int64,1}:
 1
 2
 3

julia> rowvec = permutedims(colvec)
1×3 Array{Int64,2}:
 1  2  3

julia> permutedims(rowvec)
3×1 Array{Int64,2}:
 1
 2
 3

За да преобразувате матрица (или който и да е двуизмерен масив) във вектор колона, използвайте vec. Тъй като Джулия съхранява двумерни масиви по колони, това ще обхване всяка колона на свой ред. Имайте предвид, че размерите на 2D масива са показани като <rows>x<cols> Array{<type>,2}.

julia> matrix = [1 4 
                 2 5 
                 3 6]
3×2 Array{Int64,2}:
 1  4
 2  5
 3  6  

julia> colvec = vec(matrix)
6-element Array{Int64,1}:
 1
 2
 3
 4
 5
 6

За да преобразувате този colvec обратно в оригиналния масив, трябва да знаете размерите на този оригинален масив. ndims(x) брои размерите на x, а size(x) дава броя на елементите във всяко измерение на x.

julia> reshape(colvec, size(matrix))
3×2 Array{Int64,2}:
 1  4
 2  5
 3  6

Можете да транспонирате записите с permutedims(matrix).

julia> matrix
3×2 Array{Int64,2}:
 1  4
 2  5
 3  6

julia> permutedims(matrix)
2×3 Array{Int64,2}:
 1  2  3
 4  5  6

Същите принципи се прилагат и за по-високомерни масиви.

array = reshape(collect(1:12), (3, 2, 2))
3×2×2 Array{Int64,3}:
[:, :, 1] =
 1  4
 2  5
 3  6

[:, :, 2] =
 7  10
 8  11
 9  12

julia> vec(array)
12-element Array{Int64,1}:
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12

За работа с вложени масиви предлагам да използвате RecursiveArrayTools.jl.

Има доста неща в кода по-горе, но просто се фокусираме върху вашата отправна точка и очаквания резултат:

Защо вложен масив?

Вашето разбиране създава масива [ix*0.1 iy*0.1] за всяка комбинация от ix и iy, така че бих казал, че изрично сте го поискали.

Вероятно има някои хитри начини или да направите това с фантастично разбиране, или по някакъв начин да изравните вложения масив, но в случаи като този обичам да бъда ясен за това, което се опитвам да постигна:

ps = zeros(10,10,2) # 10x10x2 Array{Float64,3}
for ix = 1:10, iy = 1:10
        ps[ix, iy, :] = [ix*0.1 iy*0.1]
end

Ако става въпрос за едноредов, можете да обмислите създаването на двата масива 10x10 в разбиранията и след това да ги свържете в трето измерение:

ps = cat([ix*0.1 for ix=1:10, iy=1:10], [iy*0.1 for ix=1:10, iy=1:10], dims = 3)

Други са дали отговори, които помагат за разрешаването на вашия проблем, така че предпочитам просто да прегледам вашия пример и да се опитам да обясня какво се случва. Изглеждате доста разочарован, което не е необичайно, когато изучавате нов език, но повечето от оплакванията ви изглежда са, защото Джулия е последователна.

ps = [ [ix*0.1 iy*0.1] for ix=1:10, iy=1:10 ]
# 10×10 Array{Array{Float64,2},2}:
# Oh, this is nested array? I wand just simple 3D array 10x10x2

Тук създавате масив 10x10, където всеки елемент е матрица 1x2. Това е, което искаш, Джулия не е трудна или неясна, просто е последователна и ясна.

scatter( ps[:,:,1], ps[:,:,2], markersize = 2, markerstrokewidth = 0, aspect_ratio=:equal )
# ERROR: BoundsError: attempt to access 10×10 Array{Array{Float64,2},2} at index [Base.Slice(Base.OneTo(10)), Base.Slice(Base.OneTo(10)), 2]

Имате 2D масив, така че не можете да индексирате в него с 3 индекса.

sh = size(ps)
# (10,10)

ps = reshape( ps, ( sh[1]*sh[2],2) )
# ERROR: DimensionMismatch("new dimensions (100, 2) must be consistent with  array size 100")
# Oh dear :(

Имате масив 10x10 и се опитвате да го преоформите в масив 100x2. Новият масив ще има 200 елемента, което е два пъти повече от оригинала, така че това не може да работи.

ps = reshape( ps, ( sh[1]*sh[2],:) )
# 100×1 Array{Array{Float64,2},2}

Тук го преформатирате в масив 100x1, това е добре.

xs = ps[:,1]
# 100-element Array{Array{Float64,2},1}
# ??? WTF? ... this arrays looks like whole 'ps' 

И сега вие питате за първата (и единствена) колона от новата, преработена ps. Така че, естествено, получавате всички данни. Забележете, че xs сега е 1D масив, а не 100x1 2D масив.

ys = ps[:,2] 
# ERROR: BoundsError: attempt to access 100×1 Array{Array{Float64,2},2} at index [Base.Slice(Base.OneTo(100)), 2]

Искате втората колона от масив 100x1.

xs = ps[:][1]
# 1×2 Array{Float64,2}: 
#  0.1  0.1
#  But I want all xs  (ps[:,1]), not (ps[1,:]) 

ps[:] превръща ps в 1D вектор със 100 елемента и след това питате за първия елемент от това. Струва ми се очаквано поведение.

# Let's try some broadcasting
xs = ps.[1]
# ERROR: syntax: invalid syntax "ps.[1]"

Да, това не работи и не е неразумно да се очаква, че може, но това е възможна бъдеща функция. Може би търсите first.(ps), което чете първия елемент от всеки елемент на ps. По същия начин last.(ps) чете последния елемент от всеки елемент от ps.

xs = .ps[1]
# ERROR: syntax: invalid identifier name "."

Това не е валиден синтаксис. Синтаксисът на точка работи само с функции и оператори.

# Perhaps transpose will help?
ps_ = ps'   #' stackoverflow syntax highlighting for Julia is broken ?
# 1×100 LinearAlgebra.Adjoint{LinearAlgebra.Adjoint{Float64,Array{Float64,2}},Array{Array{Float64,2},2}}:
# OMG! ... That is even worse

Не съм сигурен какво искаш да се случи тук. Transpose връща мързелив тип данни от съображения за производителност. Доста е спретнато.

scatter( ps[:,1], ps[:,2], markersize = 2, markerstrokewidth = 0, aspect_ratio=:equal )
# Nope

Доколкото си спомням, променихте ps в масив 100x1, така че ps[:,2] не може да работи.