Map-Thread-Through-Apply a list of functions onto a list of (lists of) values

Question

I have a list of functions:

fns = {f, g, h}

and a list of triples:

list = {{1,2,3},{11,22,33},{111,222,333},{1111,2222,3333}};

What's the best way to apply f to the first element of every triple, g to the second elements, and h to the last elements?

{
  {f[1], g[2], h[3]}, 
  {f[11], g[22], h[33]}, 
  {f[111], g[222], h[333]}, 
  {f[1111], g[2222], h[3333]}
}

(I know a few methods, but I'm looking for more.)

Suddenly everybody is using Compose; I think I started a trend. — Mr.Wizard, Sep 30 '12 at 06:48
@Mr.Wizard Compose[] is supposed to be an obsolete function, though.. — J. M.'s missing motivation, Sep 30 '12 at 09:46
@J.M. I know, which is why I'm amused that three answers below are using it. — Mr.Wizard, Sep 30 '12 at 09:50
@Mr.Wizard You sure it were you? Have a look here, here, and here,for example :-). — Leonid Shifrin, Sep 30 '12 at 13:26
@Leonid three replies come to mind: (1) You don't think I actually read all that stuff do you? (2) I'm senile and I have no idea why they trust me with the keys. (3) Great minds think alike. -- Take your pick. — Mr.Wizard, Sep 30 '12 at 13:42
@Mr.Wizard I'dpick #3 :-). Besides, neither of us started the trend, it was started by the designer of mma, responsible for Compose (in this case, most likely Stephen Wolfram himself). — Leonid Shifrin, Sep 30 '12 at 13:46
@J.M. I think it might be obsolete because it feels somewhat misnamed. A shame, because it is squatting on a decent shorter name for Composition -- a mistake I still make from time to time when writing code. The semantics of Compose are also a bit of a mixed bag: part Lisp funcall and part Composition. The former meaning (#@##2&) is what people are using for this question, and I wouldn't mind seeing another name given to that -- much like Identity is a name for #&. Call perhaps, or the lengthy FunctionCall? — WReach, Sep 30 '12 at 14:01
@WReach, if my opinion counts for anything, I was bummed when they "replaced" Compose[] with Composition[]. Oh well... — J. M.'s missing motivation, Sep 30 '12 at 14:06
Why did't anybody use Composite instead of Compose if indeed, Compose is being retired? — Gary Boswell, Oct 03 '12 at 16:58
@Gary I presume you mean Composition -- it wouldn't really be applicable here as I see it. — Mr.Wizard, Oct 04 '12 at 03:20
Brett, it's your perogative to Accept whatever answer you want, but why did you select what appears to be an inferior method? — Mr.Wizard, Oct 04 '12 at 03:21
@Mr.Wizard My reasons are completely irrational and focus more on what I consider elegant or interesting approaches rather than absolute speed. So I liked the approaches that used Inner and ListCorrelate over faster ones that used Map. (I should also say that my final code will probably end up using Leonid's double Transpose. And for what it's worth, there was also much up-voting involved on my part prior to finally accepting an answer.) — Brett Champion, Oct 04 '12 at 04:21

WReach · Accepted Answer · 2016-07-17T14:06:19.077

32

How about:

Inner[#2@#1 &, list, fns, List, 2]

or

Inner[Compose, fns, Transpose@list, List] (* Note, that Compose is obsolete *)

or

MapIndexed[fns[[Last@#2]]@#1 &, list, {2}]

or

ListCorrelate[{fns}, list, {1, -1}, {}, Compose, Sequence]

or

MapThread[Compose, {Array[fns &, Length@list], list}, 2]

or

ReplacePart[list, {i_, j_} :> fns[[j]][list[[i, j]]]]

or

list // Query[All, Thread[Range@Length@fns -> fns]]

or (cheating a little)

list // Query[All, {1 -> f, 2 -> g, 3 -> h}]

edited Jul 17 '16 at 14:06

answered Sep 30 '12 at 01:21

WReach

68,832
4
164
269

The Inner approach is the one I'm currently using. – Brett Champion Sep 30 '12 at 01:28
I added another method to make up for it :) – WReach Sep 30 '12 at 01:48
Like J.M. says Compose has been obsolete since more than 20(!) years. – stevenvh Oct 03 '12 at 17:12
@steven, that's nothing; Mathematica 8 still has Release[], and that has been deprecated far longer... – J. M.'s missing motivation Oct 03 '12 at 17:16
@J.M. "far longer" seems a bit difficult; according to the documentation center both are obsolete since version 2 (1991), and I can't imagine functions being deprecated starting version 1 :-). – stevenvh Oct 03 '12 at 17:19
@steven, maybe my memory's going, but it was kind of deprecated by version 1.2 ... maybe a Wolfram employee can confirm. – J. M.'s missing motivation Oct 03 '12 at 17:22

Leonid Shifrin · Answer 2 · 2012-09-29T21:31:58.437

26

What about

Map[MapThread[Compose, {fns, #}] &, list]

or

Transpose@MapThread[Map, {fns, Transpose[list]}]

edited Sep 29 '12 at 21:31

answered Sep 29 '12 at 21:26

Leonid Shifrin

114,335
15
329
420

1

Like J.M. says Compose has been obsolete since more than 20(!) years. – stevenvh Oct 03 '12 at 17:13
1

@stevenvh And so :-) ? – Leonid Shifrin Oct 03 '12 at 17:15
2

@steven, it may not exactly be recommended, but it still works. From an old army saw: "if a dumb thing works, then it ain't dumb." – J. M.'s missing motivation Oct 03 '12 at 17:23
@Leonid - The documentation center doesn't give any description of it any more, so how can it help OP, when he doesn't know what it does? (You don't explain it either) – stevenvh Oct 04 '12 at 15:53
@stevenvh Fair enough. I will add the description. But I guess the OP would know what it is, in this particular case, given his affiliation :-) – Leonid Shifrin Oct 04 '12 at 15:58
So I wonder, what should one write instead of the obsolete Compose in e.g. Inner[Compose, fns, Transpose@list, List], if one does not want to use Slot-s? What the heck is the full name of the function application function, if there is any?? – István Zachar Jul 17 '16 at 08:50
@IstvánZachar I'd still use Compose. I do use it myself sometimes in such cases. It may be obsolete, but I very much doubt that the support for it would ever be discontinued. – Leonid Shifrin Jul 17 '16 at 11:24

Mr.Wizard · Answer 3 · 2012-09-30T08:27:20.180

The OP said: "I know a few methods, but I'm looking for more." so here are my offerings for the sake of interest. The second is intentionally a bit convoluted. The third may actually be of interest as the method could be used for in-place modification.

With[{op = MapIndexed[#[Slot @@ #2] &, fns]}, op & @@@ list]

Fold[RotateLeft@MapAt[#2, #, 1] &, list\[Transpose], Function[x, x /@ # &] /@ fns]\[Transpose]

Module[{x = list\[Transpose]}, Table[x[[i]] = fns[[i]] /@ x[[i]], {i, Length@x}]; x\[Transpose]]

Or for in-place modification:

With[{x = list}, Table[x[[All, i]] = fns[[i]] /@ x[[All, i]], {i, Length@First@x}]; x]

This post is primarily to provide the service of comparative timings. I will be using Mathematica 7.

Timings using an array of 1.5 million Integers and three inert symbolic heads:

fns = {f, g, h};
list = RandomInteger[1*^6, {500000, 3}];
times = timeAvg[#[]] & /@ methods;
BarChart[MapThread[Labeled, {times, methods}]]

Mathematica graphics

Using an array of Reals and three trig functions:

fns = {Sin, Cos, Csc};
list = RandomReal[1*^6, {500000, 3}];
times = timeAvg[#[]] & /@ methods;
BarChart[MapThread[Labeled, {times, methods}]]

Mathematica graphics

To explore performance with different shapes here is as above but with 500 random trig functions:

fns = RandomChoice[{Sin, Cos, Sec, Csc, Tan}, 500];
list = RandomReal[1*^6, {5000, 500}];
times = timeAvg[#[]] & /@ methods;
BarChart[MapThread[Labeled, {times, methods}]]

Mathematica graphics

Functions as I named and used them:

SetAttributes[timeAvg, HoldFirst]
timeAvg[func_] := 
  Do[If[# > 0.3, Return[#/5^i]] & @@ Timing@Do[func, {5^i}], {i, 0, 15}]

leonid1[] := Map[MapThread[Compose, {fns, #}] &, list]
leonid2[] := Transpose@MapThread[Map, {fns, Transpose[list]}]
rm1[]     := Replace[list, x_List :> MapIndexed[fns[[First@#2]]@#1 &, x], {1}]
rm2[]     := MapIndexed[fns[[First@#2]]@#1 &, #] & /@ list
kguler1[] := Inner[#1@#2 &, fns, #, List] & /@ list
kguler2[] := Inner[Compose, fns, #, List] & /@ list
wreach1[] := Inner[#2@#1 &, list, fns, List, 2]
wreach2[] := MapIndexed[fns[[Last@#2]]@#1 &, list, {2}]
wreach3[] := ListCorrelate[{fns}, list, {1, -1}, {}, Compose, Sequence]
wreach4[] := MapThread[Compose, {Array[fns &, Length@list], list}, 2]
wizard1[] := With[{op = MapIndexed[#[Slot @@ #2] &, fns]}, op & @@@ list]
wizard2[] := Fold[RotateLeft@MapAt[#2, #, 1] &, list\[Transpose], Function[x, x /@ # &] /@ fns]\[Transpose]
wizard3[] := Module[{x = list\[Transpose]}, Table[x[[i]] = fns[[i]] /@ x[[i]], {i, Length@x}]; x\[Transpose]]

methods = {leonid1, leonid2, rm1, rm2, kguler1, kguler2, wreach1, 
   wreach2, wreach3, wreach4, wizard1, wizard2, wizard3};

kglr · Answer 4 · 2012-09-29T23:14:27.153

15

Inner[#1@#2 &, fns, #, List] & /@ list
(*or *)
Inner[Compose, fns, #, List] & /@ list
% //TableForm

enter image description here

edited Sep 29 '12 at 23:14

answered Sep 29 '12 at 23:09

kglr

394,356
18
477
896

Like J.M. says Compose has been obsolete since more than 20(!) years. – stevenvh Oct 03 '12 at 17:14
2

@stevenvh And it still works just fine, thank you. :D – Mr.Wizard Jul 15 '14 at 08:42

rm -rf · Answer 5 · 2012-09-29T21:59:29.080

11

Another solution using MapIndexed and —

Replace:

Replace[list, x : {_, _, _} :> MapIndexed[fns[[First@#2]]@#1 &, x], {1}]

Map:

MapIndexed[fns[[First@#2]]@#1 &, #] & /@ list

edited Sep 29 '12 at 21:59

answered Sep 29 '12 at 21:47

rm -rf

88,781
21
293
472

Murta · Answer 6 · 2016-07-18T10:13:03.647

7

Here is another option using Compose:

Compose@@@Thread@{fns, #}&/@list

or with Function:

Thread[fns~Function[{f, v}, f@v, Listable]~#] & /@ list

edited Jul 18 '16 at 10:13

answered Jul 18 '16 at 01:30

Murta

26,275
6
76
166

score 7 · Answer 7 · answered Jan 08 '20 at 20:14

7

This is not a complete answer, but I am posting it as one so it does not get lost in the comments. Compose has returned in Version 12 as Construct, so all solutions can now be implemented with supported and documented functions.

answered Jan 08 '20 at 20:14

Daniel W

3,416
18
31

3

Maybe should note that Compose[f, x] is equivalent to Construct[f, x] but Compose[f, g, x] is not equivalent to Construct[f, g, x]. – Michael E2 Jan 08 '20 at 21:00
@MichaelE2, thank you for noting this. I suspect from watching the design reviews online that there may be a builtin function that will solve this whole problem in 12.1 as it seems to have caught Wolfram's attention. – Daniel W Jan 08 '20 at 21:25

score 7 · Answer 8 · answered Jan 11 '23 at 11:56

7

Sorry for bothering an old question. It's not that fast but here is one way with the newer Threaded:

Function[, #1@#2, {Listable}][Threaded@fns, list]

answered Jan 11 '23 at 11:56

Silvia

27,556
3
84
164

2

(+1) I like updates like this one!!! – bmf Jan 11 '23 at 12:00
3

@bmf Thanks! Though not the fastest, the performance of Threaded is not bad. I guess people on this site haven't got into habit of using it (yet). – Silvia Jan 11 '23 at 12:13

score 3 · Answer 9 · answered Jan 11 '23 at 16:35

3

Yet another solution:

Transpose[Activate[Thread[Inactive[Map][fns, Transpose[list]]]]]

answered Jan 11 '23 at 16:35

Gustavo Delfino

8,348
1
28
58

E. Chan-López · Answer 10 · 2023-01-11T16:08:58.670

2

Just another way:

Transpose@Diagonal[(Thread /@ Through[fns[#]]) & /@ (Transpose@list)]
({{f[1], g[2], h[3]}, {f[11], g[22], h[33]}, {f[111], g[222], h[333]}, {f[1111], g[2222], h[3333]}})

Or using Outer:

Transpose@Diagonal[Transpose@*Thread@*Through /@ Outer[fns @@ #1 &@*List,Transpose@list]]

edited Jan 11 '23 at 16:08

answered Jan 11 '23 at 15:48

E. Chan-López

23,117
3
21
44

1

Nicely done mate - comment/reminder to upvote - I used max votes today – bmf Jan 11 '23 at 15:59
1

Hi, mate! We are starting the year with a lot of energy :-) – E. Chan-López Jan 11 '23 at 16:10

Map-Thread-Through-Apply a list of functions onto a list of (lists of) values

10 Answers10

Linked

Related