Julia - консоль ведет себя иначе, чем include ("myfile.jl")

Question

Я хотел бы выполнить следующий код, который прекрасно работает, когда я печатаю каждую строку в консоль Julia в Windows 10, но выдает ошибку из-за несоответствующего типа LinearAlgebra.Adjoint{Float64,Array{Float64,2}} (мой следующий код ожидает Array{Float64,2}) .

Это код:

x = [0.2, 0.1, 0.2]
y = [-0.5 0.0 0.5]

fx = x * y
fy = fx'

return fx::Array{Float64,2}, fy::Array{Float64,2}

Существует ошибка типа, потому что fy имеет тип LinearAlgebra.Adjoint{Float64,Array{Float64,2}} вместо Array{Float64,2}.

Как я могу сделать транспонирование и получить "нормальный" объект Array {Float64,2}?

И почему это работает, когда я печатаю каждую строку в моей консоли Julia, а не когда я запускаю файл через include ("myfile.jl")?

Answer 1

Для получения нормального Matrix{Float64} используйте:

fy = permutedims(fx)

или

fy = Matrix(fx')

Эти два в общем не эквивалентны на 100%, так как fx' является рекурсивной присоединенной операцией (сопряженная транспонирование), в то время как permutedims является нерекурсивной транспонированием, но в вашем случае они дадут тот же результат.

Что означает рекурсивный сопряженный точно?

• рекурсивный: сопряженное транспонирование применяется рекурсивно ко всем элементам массива (в вашем случае у вас есть массив чисел, а транспонирование числа - это одно и то же число, поэтому это ничего не меняет);
• adjoint: если бы у вас были комплексные числа, то операция вернула бы их комплексные конъюгаты (в вашем случае у вас есть действительные числа, поэтому это ничего не меняет);

Вот пример, когда обе вещи имеют значение:

julia> x = [[im, -im], [1-im 1+im]]
2-element Array{Array{Complex{Int64},N} where N,1}:
 [0+1im, 0-1im]
 [1-1im 1+1im]

julia> permutedims(x)
1×2 Array{Array{Complex{Int64},N} where N,2}:
 [0+1im, 0-1im]  [1-1im 1+1im]

julia> Matrix(x')
1×2 Array{AbstractArray{Complex{Int64},N} where N,2}:
 [0-1im 0+1im]  [1+1im; 1-1im]

Однако, если вам действительно не нужно, вам не нужно это делать, если вам действительно необходимо получить сопряженную транспонированность ваших данных. Достаточно изменить утверждение типа на

return fx::Array{Float64,2}, fy::AbstractArray{Float64,2}

или

return fx::Matrix{Float64}, fy::AbstractMatrix{Float64}

Conjugate transpose был разработан, чтобы избежать ненужного распределения данных, и в большинстве случаев это будет более эффективным для вас (особенно с большими матрицами).

Наконец строка:

return fx::Array{Float64,2}, fy::Array{Float64,2}

выдает ошибку также в командной строке Julia (не только при запуске из скрипта).

Answer 2

Используйте collect, чтобы получить копию фактических данных, а не преобразованный вид оригинала (обратите внимание, что это правило применяется ко многим другим подобным ситуациям):

julia> x = [0.2, 0.1, 0.2];                         
julia> y = [-0.5 0.0 0.5];

julia> fx = x * y                                     
3×3 Array{Float64,2}:                                 
 -0.1   0.0  0.1                                      
 -0.05  0.0  0.05                                     
 -0.1   0.0  0.1                                      

julia> fy = fx'                                       
3×3 LinearAlgebra.Adjoint{Float64,Array{Float64,2}}:  
 -0.1  -0.05  -0.1                                    
  0.0   0.0    0.0                                    
  0.1   0.05   0.1                                    

julia> fy = collect(fx')                              
3×3 Array{Float64,2}:                                 
 -0.1  -0.05  -0.1                                    
  0.0   0.0    0.0                                    
  0.1   0.05   0.1