Table with multiple iterators running parallel

Question

I want to use Table to generate a list, but it only allows one iterator to increment at a time. So in

Table[i*r, {i, 0, 5}, {r, 0, 5}]

r will run 0 through 5 for i = 0, then change i and run through r again etc., giving 36 elements in a 6 x 6 array. But I want a list of only 6 elements, so that i and r are changed at the same time, in parallel. So it would give 0*0, then 1*1, 2*2 etc. Giving the output of:

{0, 1, 4, 9, 16, 25}  (* <-This is what I want. *)

Is this possible with Table or anything else?

Also I know I could do:

Table[i*i, {i,0,5}]

But this is just an example, and in my project this way won't work. Also if at all possible I would like to use a list for one iterator's values, but this isn't so important.

Answer 1

There are two easy approaches that come to mind. The first is to simply use MapThread.

MapThread[foo, {Range[0, 4], Range[24, 32, 2]}]

{foo[0, 24], foo[1, 26], foo[2, 28], foo[3, 30], foo[4, 32]}

If you are collecting all results this is probably a perfectly good approach as memory is unlikely to be a problem.

The second is to define the relationship between the two iterators and then use only one. For the example above the second iterator can be generated from the first with the formula 2 (# + 12). We could then write:

Table[foo[i, 2 (i + 12)], {i, 0, 4}]

{foo[0, 24], foo[1, 26], foo[2, 28], foo[3, 30], foo[4, 32]}

I suppose you would like a syntax more like Table. The question is then how to automate this.

For MapThread I propose:

SetAttributes[pTable1, HoldAll]

pTable1[expr_, iter : {_Symbol, __} ..] :=
 MapIndexed[Set, Hold[iter][[All, 1]]] /. List -> Slot /. _[x__] :>
   MapThread[
     Block[{x}, expr] &,
     Range @@@ Rest /@ {iter}
   ]

Now:

pTable1[foo[x, y], {x, 0, 4}, {y, 24, 32, 2}]

{foo[0, 24], foo[1, 26], foo[2, 28], foo[3, 30], foo[4, 32]}

---

While working on the second method it occurred to me that a different syntax is superior. Ranges should instead be given as a starting value and a step size rather than start,end,step, then a single repetition value for all iterators should be given. This both shortens syntax and assures agreement of length.

SetAttributes[pTable2, HoldAll]

pTable2[expr_, iter : {_Symbol, __} .., n_Integer] :=
  Module[{Z},
    Hold[iter] /. {i_, a_, s_: 1} :> (i = a - s + s Z) /. _[x__] :>
      Block[{x}, Table[expr, {Z, n}]]
  ]

Example use:

pTable2[foo[x, y], {x, 0}, {y, 24, 2}, 5]

{foo[0, 24], foo[1, 26], foo[2, 28], foo[3, 30], foo[4, 32]}

---

We can prettify either function by adding syntax highlighting similar to Table, indicating the scoped Symbols in the iterators:

SyntaxInformation[pTable2] = SyntaxInformation[Table];

Now input appears as:

As indicated x and y are correctly scoped, and evaluation is as in Table:

x = y = "Fail!";
bar := foo[x, y];
pTable2[bar, {x, 0}, {y, 24, 2}, 5]

{foo[0, 24], foo[1, 26], foo[2, 28], foo[3, 30], foo[4, 32]}

Answer 2

You can use a Table with variable iterator limit. e.g.

Table[f[i, r], {i, 0, 5}, {r, {i}}]

{{f[0, 0]}, {f[1, 1]}, {f[2, 2]}, {f[3, 3]}, {f[4, 4]}, {f[5, 5]}}

Or

Table[f[i, r], {i, 0, 5}, {r, 0, i, 2}] // TableForm

f[0,0]        
f[1,0]      
f[2,0]  f[2,2]  
f[3,0]  f[3,2]  
f[4,0]  f[4,2]  f[4,4]
f[5,0]  f[5,2]  f[5,4]

Answer 3

MapThread[] is probably what you want, but here's another idea: treat the two vectors as rows of a matrix, and then iterate over the columns, applying (Apply[]) and mapping (Map[]) as necessary. Your original problem could have been done this way:

Table[Apply[#1*#2 &, 
    Part[{Range[0, 5], Range[0, 5]}, All, i]], {i, 6}]

which yields:

{0, 1, 4, 9, 16, 25}

written more compactly:

Table[Apply[Times, {Range[0, 5], Range[0, 5]}[[All, i]]], {i, 6}]