Permutedims does not reassign inputted matrix

New to Julia
1

I have the following codes:

julia> A = [1 2; 3 4];

julia> function test!(A)
           A = permutedims(A, [2,1])
       end
test! (generic function with 1 method)

julia> test!(A)
2×2 Array{Int64,2}:
 1  3
 2  4

julia> A
2×2 Array{Int64,2}:
 1  2
 3  4

Could someone explain why I reassign A inside test!, but A is not changed? Thanks!

2

Never mind, I have answer to my own question :smiley: (I can change the values but cannot change the pointer and permutedims create a new local variable). I have another related question. I have the following codes:

A = [1 2; 3 4]
b = [5.0 7; 6 8]

function solve!(A,b)
    sol = A\b
    b .= sol
end

function solveTwoTime!(A,b)
    solve!(A,b)
    b = permutedims(b,[2,1]) # permute rows vs columns
    solve!(A,b)
    b = permutedims(b,[2,1])
end

The idea is I want to call solve two times, first with the columns, then with the rows. However, I do not want to create new local variable. If permutedims can manipulate b (like reshape) and does not create new local variable, then it will be great! Is there anyway to handle this case? Basically the idea is I do not want to create a local variable to improve the performance. Thanks.

3

Just do b' which is a lazy transpose. Also, consider calling factorize(A) and use the returned object to solve twice.

Also see

julia> using LinearAlgebra

help?> LinearAlgebra.ldiv!
  ldiv!(Y, A, B) -> Y

  Compute A \ B in-place and store the result in Y, returning the result.

  The argument A should not be a matrix. Rather, instead of matrices it should be
  a factorization object (e.g. produced by factorize or cholesky). The reason for
  this is that factorization itself is both expensive and typically allocates
  memory (although it can also be done in-place via, e.g., lu!), and
  performance-critical situations requiring ldiv! usually also require
  fine-grained control over the factorization of A.
1 Like