MapThread with non-rectangular lists

Question

MapThread works fine and dandy with rectangular list structures:

MapThread[f, {{{a, b}, {c, d}}, {{1, 2}, {3, 4}}}, 2]

{{f[a, 1], f[b, 2]}, {f[c, 3], f[d, 4]}}

But with a ragged structure, it starts complaining:

MapThread[f, {{{a, b}, {c, d, e}}, {{1, 2}, {3, 4, 5}}}, 2]

MapThread::mptd: "Object {{a,b},{c,d,e}} at position {2, 1} in MapThread[f,{{{a,b},{c,d,e}},{{1,2},{3,4,5}}},2] has only 1 of required 2 dimensions."

whereas I'd like:

{{f[a, 1], f[b, 2]}, {f[c, 3], f[d, 4], f[e, 5]}}

I can't see any obvious way to achieve a pairing of the corresponding elements, but maybe you can?

Rojo · Accepted Answer · 2012-07-31T13:46:02.233

16

Perhaps something like this, as a more general alternative? However, without tweaking it forget about level specification

Function[Null, f[##], Listable] @@ A

edited Jul 31 '12 at 13:46

answered May 28 '12 at 03:49

Rojo

42,601
7
96
188

The magic of Listable! I knew there must have been some nice way to do it. – wxffles May 28 '12 at 04:27
@wxffles I like it. If you actually want to give the arguments as separate lists like in your solution, you don't even need the Apply – Rojo May 28 '12 at 04:37
This is crazy amazing! MMA is effin' nuts in its state space a.e.! – Gravifer Nov 01 '22 at 14:09

score 13 · Answer 2 · answered May 28 '12 at 03:25

13

Here's a way to do it by mapping MapThread:

MapThread[f, #] & /@ Transpose[{{{a, b}, {c, d, e}}, {{1, 2}, {3, 4, 5}}}]
(* {{f[a, 1], f[b, 2]}, {f[c, 3], f[d, 4], f[e, 5]}} *)

answered May 28 '12 at 03:25

rm -rf

88,781
21
293
472

1

This works great if you are working at level 2. I was hoping for something more general. Next time I'll try asking! – wxffles May 28 '12 at 03:42
4

@wxffles please provide more examples if you want a more general solution. – Mr.Wizard May 28 '12 at 03:47

score 12 · Answer 3 · answered May 28 '12 at 03:49

12

It's probably bad form to answer your own question, but I did manage to get something to work while I was waiting:

myMapThread[f_, list1_, list2_, level_] := 
  Module[{s}, Function[s, 
     Reap[MapIndexed[Sow[f[#1, s[[Sequence @@ #2]]]] &, list1, {level}]][[1]]]
     [list2]];

Usage:

myMapThread[f, {{a, b}, {c, d, e}}, {{1, 2}, {3, 4, 5}}, 2]

{{f[a, 1], f[b, 2]}, {f[c, 3], f[d, 4], f[e, 5]}}

It's quite ugly though.

answered May 28 '12 at 03:49

wxffles

14,246
1
43
75

5

It's not bad form, in fact it is actively encouraged. – rcollyer May 28 '12 at 03:51

score 7 · Answer 4 · answered May 09 '20 at 16:53

7

ClearAll[raggedThread]
raggedThread = Inner[Thread @* #, ##2, List] &;

Example:

raggedThread[f, {{a, b}, {c, d, e}}, {{1, 2}, {3, 4, 5}}]

{{f[a, 1], f[b, 2]}, {f[c, 3], f[d, 4], f[e, 5]}}

answered May 09 '20 at 16:53

kglr

394,356
18
477
896

Necromancer badge :-) – Mr.Wizard Jun 13 '20 at 13:38
Thank you @Mr.Wizard. – kglr Jun 13 '20 at 16:03

score 6 · Answer 5 · answered May 28 '12 at 12:19

MapThread[f, lst[[1 ;; 2, #]]] & /@ {1, 2}

gives

(*{{f[a, 1], f[b, 2]}, {f[c, 3], f[d, 4], f[e, 5]}}*)

If

lst2 = {{{a, b}, {c, d, e}}, {{1, 2}, {3, 4, 5}}, {{aa, bb}, {cc, dd, ee}}};
MapThread[f, lst2[[1 ;; 3, #]]] & /@ {1, 2}

gives

(*{{f[a, 1, aa], f[b, 2, bb]}, {f[c, 3, cc], f[d, 4, dd], f[e, 5, ee]}}*)

score 2 · Answer 6 · answered Oct 21 '23 at 23:33

2

x = {{a, b}, {c, d, e}};
y = {{1, 2}, {3, 4, 5}};

MapApply[f] /@ Transpose /@ Transpose[{x, y}]

{{f[a, 1], f[b, 2]}, {f[c, 3], f[d, 4], f[e, 5]}}

answered Oct 21 '23 at 23:33

eldo

67,911
5
60
168

score 1 · Answer 7 · answered Oct 22 '23 at 19:22

Using the third argument of GroupBy to cover the ragged array case:

myMapThread[f_, list_] := 
If[TensorQ[list], f @@@ # &@*Thread /@ Transpose@list, 
Values[GroupBy[Catenate[list], Length, f @@@ # &@*Thread]]]

Testing myMapThread:

list1 = {{{a, b}, {c, d}}, {{1, 2}, {3, 4}}};
list2 = {{{a, b}, {c, d, e}}, {{1, 2}, {3, 4, 5}}};
myMapThread[f, list1]
({{f[a, 1], f[b, 2]}, {f[c, 3], f[d, 4]}})
myMapThread[f, list2]
({{f[a, 1], f[b, 2]}, {f[c, 3], f[d, 4], f[e, 5]}})

kglr · Answer 8 · 2023-10-22T00:35:41.417

0

threadRagged = Apply[#, Flatten[{##2}, {{2}, {3}}], {2}] &;

Examples:

{x, y} = {{{a, b}, {c, d, e}}, y = {{1, 2}, {3, 4, 5}}};
threadRagged[f, x, y]

{{f[a, 1], f[b, 2]},   
 {f[c, 3], f[d, 4], f[e, 5]}}

lst2 = {{{a, b}, {c, d, e}}, {{1, 2}, {3, 4, 5}}, {{aa, bb}, {cc, dd, ee}}};
threadRagged[F, ## & @@ lst2]

 {{F[a, 1, aa], F[b, 2, bb]},   
  {F[c, 3, cc], F[d, 4, dd], F[e, 5, ee]}}

edited Oct 22 '23 at 00:35

answered Oct 22 '23 at 00:23

kglr

394,356
18
477
896

score 0 · Answer 9 · answered Oct 22 '23 at 00:36

threadTwice = Map[Thread]@Thread[#@##2, List, Length @ {##2}] &;

Examples:

{x, y} = {{{a, b}, {c, d, e}}, y = {{1, 2}, {3, 4, 5}}};
threadTwice[f, x, y]

 {{f[a, 1], f[b, 2]},   
  {f[c, 3], f[d, 4], f[e, 5]}}

lst2 = {{{a, b}, {c, d, e}}, {{1, 2}, {3, 4, 5}}, {{aa, bb}, {cc, dd, ee}}};
threadTwice[f, ## & @@ lst2]

{{f[a, 1, aa], f[b, 2, bb]},   
 {f[c, 3, cc], f[d, 4, dd], f[e, 5, ee]}}

MapThread with non-rectangular lists

9 Answers9

Linked

Related