Vfrdtyky

I would like to execute the following code, which works perfectly well when I type every line into my Julia console on Windows 10, but throws an error because of the mismatching type LinearAlgebra.Adjoint{Float64,Array{Float64,2}} (my subsequent code expects Array{Float64,2}).

This is the code:

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}

There is a TypeError, because fy seems to be of type LinearAlgebra.Adjoint{Float64,Array{Float64,2}} instead of Array{Float64,2}.

How can I do a transpose and get a "normal" Array{Float64,2} object ?

And why does this work when I type every line into my Julia console, but does not when I run the file via include("myfile.jl") ?

Use collect to have a copy of actual data rather than a transformed view of the original (note that this rule applies to many other similar situations):

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            

To get a normal Matrix{Float64} use:

fy = permutedims(fx)

or

fy = Matrix(fx')

Those two are not 100% equivalent in general as fx' is a recursive adjoint operation (conjugate transpose), while permutedims is a non-recursive transpose, but in your case they will give the same result.

What does recursive adjoint mean exactly?

• recursive: the conjugate transpose is applied recursively to all entries of the array (in your case you have array of numbers and transpose of a number is the same number so this does not change anything);


• adjoint: if you would have complex numbers then the operation would return their complex conjugates (in your case you have real numbers so this does not change anything);

Here is an example when both things matter:

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]

However, unless you really need to you do not have to do it if you really need to get a conjugate transpose of your data. It is enough to change type assertion to

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

or

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

Conjugate transpose was designed to avoid unnecessary allocation of data and most of the time this will be more efficient for you (especially with large matrices).

Finally the line:

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

throws an error also in the Julia command line (not only when run from a script).