"vecnorm" : column/row-wise norm

I have a 2D array, and want to treat each row (or column) as a vector and find norm of it

a = [1 2 3 ; 4 5 6]
a
2×3 Array{Int64,2}:
 1  2  3
 4  5  6

The following is what I have tried and their results.

Both norm.(a) and vecnorm.(a) gives

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

While norm(a) gives 9.508032000695724 and vecnorm(a) gives 9.539392014169456

For now, to get what I want, I have to do the following

a = [[1,2,3],[4, 5, 6]]

a
2-element Array{Array{Int64,1},1}:
 [1, 2, 3]
 [4, 5, 6]

Then, both norm. and vecnorm. works

vecnorm.(a)
norm.(a)

gives

2-element Array{Float64,1}:
 3.74166
 8.77496

I would like to know how can I have something similar to this matlab example directly from a 2D array.

1 Like

There is currently no direct function to take the norm of a 2D array by dimension. The easiest way would probably be to do either of the 2 functions below:

julia> A = rand(5,4);
                                         
julia> f1(A,d=1) = sqrt.(sum(abs2,A,d))
f1 (generic function with 1 method)               
                                                  
julia> f2(A) = [vecnorm(A[:,i]) for i=1:size(A,2)]
f2 (generic function with 1 method)               

julia> @btime f1($A)
  128.103 ns (2 allocations: 224 bytes)
1×4 Array{Float64,2}:
 1.08137  1.1315  1.23828  1.35529

julia> @btime f2($A)                    
  327.377 ns (11 allocations: 736 bytes)
4-element Array{Float64,1}:             
 1.08137                                
 1.1315                                 
 1.23828                                
 1.35529                                

f1 is faster because it acts mostly in place. It also allows you to change the dimension more easily.

5 Likes

While f1 is likely to always be the best, f2 can be made slightly faster by replacing A[:,i] with @view A[:,i] to avoid the copy operation.

Another alternative is to use mapslices which applies a specified function to slices through the matrix (much like is being done manually with f2)

julia> f3(A) = mapslices(norm, A, dims=1)
f3 (generic function with 1 method)

julia> @btime f3($A)
  5.358 μs (73 allocations: 3.22 KiB)
1×4 Array{Float64,2}:
 0.824996  1.40544  1.19838  1.6095

but it is painfully slow in comparison with either f1 or f2.

1 Like

Thanks for your additional info. I also found this discussion. Good to learn another new thing.

Maybe it is more intuitive think about list comprehension in this kind of problem (any problem with operation across matrices and vectors, really).
My favorite way to get a list of norms of the vectors represented as lines in a matrix is :
norms = [norm(m[i,:]) for i=1:size(m)[1]]
It is not super compact as it would be in matlab, but perhaps more understandable as you can see that you are calculating some norm for each line of the matrix and getting a list of those norms. When I do this in matlab I always have to check if I’m calculating the norm “vertically” or “horizontally” in the matrix to make sure I’ll get what I want.

Or just norm.(eachcol(m))

4 Likes