Odtnhj

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.AdjointFloat64,ArrayFloat64,2 (my subsequent code expects ArrayFloat64,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::ArrayFloat64,2, fy::ArrayFloat64,2

There is a TypeError, because fy seems to be of type LinearAlgebra.AdjointFloat64,ArrayFloat64,2 instead of ArrayFloat64,2.

How can I do a transpose and get a "normal" ArrayFloat64,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 ArrayFloat64,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.AdjointFloat64,ArrayFloat64,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 ArrayFloat64,2: 
 -0.1 -0.05 -0.1 
 0.0 0.0 0.0 
 0.1 0.05 0.1 

To get a normal MatrixFloat64 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 ArrayArrayComplexInt64,N where N,1:
 [0+1im, 0-1im]
 [1-1im 1+1im]

julia> permutedims(x)
1×2 ArrayArrayComplexInt64,N where N,2:
 [0+1im, 0-1im] [1-1im 1+1im]

julia> Matrix(x')
1×2 ArrayAbstractArrayComplexInt64,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::ArrayFloat64,2, fy::AbstractArrayFloat64,2

or

return fx::MatrixFloat64, fy::AbstractMatrixFloat64

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::ArrayFloat64,2, fy::ArrayFloat64,2

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