Grid of all elements of an arbitrarily sized matrix

General Usage
1

I have an n*m sized array A, and I would like to create a grid of its elements. The output should look something like:

B = (A[1,1], A[2,1]
     A[1,1], A[2,2]
     ...
     A[1,1], A[2,m]
     A[1,2], A[2,1]
     A[1,2], A[2,2]
     ...
     A[1,2], A[2,m]
     ...
     A[n,1], A[n,m])

My first approach would be to do something like this:

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

B = collect(Iterators.product(A))

However, this only returns

4×2 Matrix{Tuple{Int64}}:
 (1,)  (5,)
 (2,)  (6,)
 (3,)  (7,)
 (4,)  (8,)

Instead of the desired output above.

Any ideas?

3

I guess you want something along the lines of

julia> Iterators.product(A[:, 1], A[:, 2]) |> collect
4×4 Matrix{Tuple{Int64, Int64}}:
 (1, 5)  (1, 6)  (1, 7)  (1, 8)
 (2, 5)  (2, 6)  (2, 7)  (2, 8)
 (3, 5)  (3, 6)  (3, 7)  (3, 8)
 (4, 5)  (4, 6)  (4, 7)  (4, 8)

Tweak shape etc. as needed.

1 Like
4

Thanks for the suggestion. But this only reshapes the array. But what I need is a bit different.
Let me give you an example:

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

And the result should be:

B = [1 5;
     1 6;
     1 7;
     1 8;
     2 5;
     2 6;
     2 7;
     2 8;
     3 5;
     3 6;
     3 7;
     3 8;
     4 5;
     4 6;
     4 7;
     4 8;]

I could write it in a nested loop but it should be able to handle arrays of any n*m.
The Iterator.product() function is promising but I do not know how to get it to work with a matrix. It does work with separate vectors though. And I don’t know how to make it work without inputting a fixed amount of vectors.

5

Thanks! That’s what I also thought. I just need to be able to make the

A[:, 1], A[:, 2]

flexible. So, I need to be able to input a matrix with any number of columns.

6

This should work, though I’m unsure if it is efficient:

Iterators.product(eachcol(A)...) |> collect

If you want one tall vector, just pass it into vec:

Iterators.product(eachcol(A)...) |> collect |> vec
2 Likes
7

That works. Awesome, thanks!
Can you just quickly explain what the three dots do?

Sorry, I just switched to Julia.

8

The three dots, the splatting operator, unpacks a collection of elements into a list of arguments.

For example, if you have a function, foo(x, y) that takes two arguments, you cannot call it like this: foo([1, 2]). But you can unpack the elements from the array into two arguments: foo([1, 2]...)

You can read docstrings for operators and functions like this:

julia> ?  # type question mark. The prompt turns into

help?> ...  # type the operator you are wondering about, like ...
search: ...

  ...


  The "splat" operator, ..., represents a sequence of arguments. ... can be used  
  in function definitions, to indicate that the function accepts an arbitrary     
  number of arguments. ... can also be used to apply a function to a sequence of  
  arguments.

  Examples
  ≡≡≡≡≡≡≡≡≡≡

(The same syntax is used for “slurping”, which is sort of the opposite.)

1 Like
9

That makes sense. Thanks!