Confusion with eachrow and pipe

New to Julia
1

Let’s say we have a simple 2D matrix

a = [0 1 2 3 4; 
    5 6 7 8 9; 
    10 11 12 13 14;
    15 16 17 18 19]

map

It looks like you can apply a function to rows and columns like this

julia> map(sum, eachrow(a))
4-element Vector{Int64}:
 10
 35
 60
 85

and you get the expected results.

list comprehension

You can also use a list comprehension like

julia> [sum(x) for x in eachrow(a)]
4-element Vector{Int64}:
 10
 35
 60
 85

pipe

but if you try to achieve that using pipes then that doesn’t work and seemingly gives you the result as if you’d asked for sums of columns

a |> eachrow |> sum
5-element Vector{Int64}:
 30
 34
 38
 42
 46

and instead using eachcol gives you the row sums

julia> a |> eachcol |> sum
4-element Vector{Int64}:
 10
 35
 60
 85

What’s all that about?

As a relative beginner, these results are quite confusing. This doesn’t seem like it makes sense.

1 Like
2

If you broadcast the piped sum over each row it seems to work alright:

a |> eachrow |> x -> sum.(x)
# equal to: sum(a,dims=2)
1 Like
3

Thanks @rafael.guerra Im my mental model, the sum is receiving a rows, one at a time, so not sure why you would need to use broadcasting in that case.

Can you offer any insights into why the naive pipe approach did not work, or why it seemed to be operating on columns and not rows?

5

eachrow(a) is an iterator of vectors, and + is defined for vectors. So sum is applying + to an accumulator.

julia> [1, 2] + [3, 4]
2-element Vector{Int64}:
 4
 6

julia> sum([[1, 2], [3, 4]]) # vector of vectors kind of like eachrow
2-element Vector{Int64}:
 4
 6
6

Should do collect(eachrow(a)) to see the vector of vectors that is piped into sum.

1 Like
7

My best take on this would be to have a look what the iterator created by “eachrow” does yields:

julia> b = collect.(eachrow(a))
4-element Vector{Vector{Int64}}:
 [0, 1, 2, 3, 4]
 [5, 6, 7, 8, 9]
 [10, 11, 12, 13, 14]
 [15, 16, 17, 18, 19]

If you collect the result you see that you get a vector of vectors. Now you can check what happens if you apply sum to such an object:

julia> sum(b)
5-element Vector{Int64}:
 30
 34
 38
 42
 46

And you can check which function is called for it:

julia> @which sum(b)
sum(a::AbstractArray; dims, kw...) in Base at reducedim.jl:873
1 Like
8

Thanks @DorianT. So in short eachrow is not generating vectors as such, but a generator which pumps out vectors?

But it’s not immediately clear why what sum is being provided with is different when doing a |> eachcol |> sum and [sum(x) for x in eachrow(a)]? I think that’s what I’m finding particularly confusing.

As in, why the need for collect when using pipes, but not when using a list comprehension?

9

Sum gets the whole iterator at once and sums the elements in the pipe version. In your list comprehension you apply one sum to each element of the iterator. You can use .|> sum though

3 Likes
10

Let’s say the rows of A are r1, r2, r3. Then the following have the same meaning:

A |> eachrow |> sum

sum(eachrow(A))

sum([r1, r2, r3])  # Sum of a list of 3 elements (each element being a vector)

r1 + r2 + r3

Your list comprehension does something else… These are equivalent:

[sum(r) for r in eachrow(A)]  # Calculate sum(r) for each row r

[sum(r1), sum(r2), sum(r2)]

Here instead of calculating the sum of three arrays we calculate three sums!

4 Likes