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.)

@J.M. I know, which is why I'm amused that three answers below are using it. — Mr.Wizard, Commented Sep 30, 2012 at 9:50
@Mr.Wizard You sure it were you? Have a look here, here, and here,for example :-). — Leonid Shifrin, Commented Sep 30, 2012 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, Commented Sep 30, 2012 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, Commented Sep 30, 2012 at 13:46
@WReach, if my opinion counts for anything, I was bummed when they "replaced" Compose[] with Composition[]. Oh well... — J. M.'s missing motivation, Commented Sep 30, 2012 at 14:06

WReach · Accepted Answer · 2016-07-17 14:06:19Z

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, 2016 at 14:06

answered Sep 30, 2012 at 1:21

WReach

69.3k4 gold badges165 silver badges272 bronze badges

$\begingroup$ The Inner approach is the one I'm currently using. $\endgroup$
– Brett Champion
Commented Sep 30, 2012 at 1:28
$\begingroup$ I added another method to make up for it :) $\endgroup$
– WReach
Commented Sep 30, 2012 at 1:48
$\begingroup$ Like J.M. says Compose has been obsolete since more than 20(!) years. $\endgroup$
– stevenvh
Commented Oct 3, 2012 at 17:12
$\begingroup$ @steven, that's nothing; Mathematica 8 still has Release[], and that has been deprecated far longer... $\endgroup$
– J. M.'s missing motivation ♦
Commented Oct 3, 2012 at 17:16
$\begingroup$ @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 :-). $\endgroup$
– stevenvh
Commented Oct 3, 2012 at 17:19

| Show 1 more comment

Leonid Shifrin · Accepted Answer · 2012-09-29 21:31:58Z

27

What about

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

or

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

edited Sep 29, 2012 at 21:31

answered Sep 29, 2012 at 21:26

Leonid Shifrin

115k16 gold badges333 silver badges424 bronze badges

1

$\begingroup$ Like J.M. says Compose has been obsolete since more than 20(!) years. $\endgroup$
– stevenvh
Commented Oct 3, 2012 at 17:13
1

$\begingroup$ @stevenvh And so :-) ? $\endgroup$
– Leonid Shifrin
Commented Oct 3, 2012 at 17:15
2

$\begingroup$ @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." $\endgroup$
– J. M.'s missing motivation ♦
Commented Oct 3, 2012 at 17:23
$\begingroup$ @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) $\endgroup$
– stevenvh
Commented Oct 4, 2012 at 15:53
$\begingroup$ @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 :-) $\endgroup$
– Leonid Shifrin
Commented Oct 4, 2012 at 15:58

| Show 2 more comments

Mr.Wizard · Accepted Answer · 2012-09-30 08:27:20Z

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 · Accepted Answer · 2012-09-29 23:14:27Z

16

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

enter image description here

edited Sep 29, 2012 at 23:14

answered Sep 29, 2012 at 23:09

kglr

401k18 gold badges488 silver badges929 bronze badges

$\begingroup$ Like J.M. says Compose has been obsolete since more than 20(!) years. $\endgroup$
– stevenvh
Commented Oct 3, 2012 at 17:14
2

$\begingroup$ @stevenvh And it still works just fine, thank you. :D $\endgroup$
– Mr.Wizard
Commented Jul 15, 2014 at 8:42

Add a comment |

rm -rf · Accepted Answer · 2012-09-29 21:59:29Z

12

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, 2012 at 21:59

answered Sep 29, 2012 at 21:47

rm -rf♦

89.3k21 gold badges296 silver badges478 bronze badges

Add a comment |

Murta · Accepted Answer · 2016-07-18 10:13:03Z

8

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, 2016 at 10:13

answered Jul 18, 2016 at 1:30

Murta

26.4k6 gold badges77 silver badges168 bronze badges

Add a comment |

Silvia · Accepted Answer · 2023-01-11 11:56:37Z

8

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, 2023 at 11:56

Silvia

27.6k3 gold badges85 silver badges165 bronze badges

2

$\begingroup$ (+1) I like updates like this one!!! $\endgroup$
– bmf
Commented Jan 11, 2023 at 12:00
3

$\begingroup$ @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). $\endgroup$
– Silvia
Commented Jan 11, 2023 at 12:13

Add a comment |

Daniel W · Accepted Answer · 2020-01-08 20:14:57Z

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 8, 2020 at 20:14

Daniel W

3,43618 silver badges32 bronze badges

3

$\begingroup$ 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]. $\endgroup$
– Michael E2
Commented Jan 8, 2020 at 21:00
$\begingroup$ @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. $\endgroup$
– Daniel W
Commented Jan 8, 2020 at 21:25

Add a comment |

E. Chan-López · Accepted Answer · 2024-07-15 23:18:01Z

5

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]}}

-Update- Or using Outer:

Map[Diagonal]@Outer[Through@*fns @@ #1 &@*List, 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]}}

edited Jul 15 at 23:18

answered Jan 11, 2023 at 15:48

E. Chan-López

31.1k3 gold badges29 silver badges50 bronze badges

1

$\begingroup$ Nicely done mate - comment/reminder to upvote - I used max votes today $\endgroup$
– bmf
Commented Jan 11, 2023 at 15:59
1

$\begingroup$ Hi, mate! We are starting the year with a lot of energy :-) $\endgroup$
– E. Chan-López
Commented Jan 11, 2023 at 16:10
$\begingroup$ @bmf Hi, mate! See the update, please! :-) $\endgroup$
– E. Chan-López
Commented Jul 15 at 23:19

Add a comment |

Gustavo Delfino · Accepted Answer · 2023-01-11 16:35:16Z

4

Yet another solution:

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

answered Jan 11, 2023 at 16:35

Gustavo Delfino

8,6871 gold badge29 silver badges60 bronze badges

Add a comment |

E. Chan-López · Accepted Answer · 2024-07-16 00:07:53Z

fns = {f, g, h};

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

Using AssociationThread and KeyValueMap:

Transpose[KeyValueMap[Thread[#1@#2] &]@AssociationThread[fns, Thread@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 Thread and MapApply as follows:

Thread[Thread[#1@#2] & @@@ Thread[{fns, Thread[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]}}

eldo · Accepted Answer · 2024-07-15 22:02:50Z

3

fns = {f, g, h};

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

Using ColumnMap by Michael Sollami

CMap = ResourceFunction["ColumnMap"];

CMap[fns, list, Range @ Length @ fns]

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

answered Jul 15 at 22:02

eldo

83.1k6 gold badges72 silver badges202 bronze badges

$\begingroup$ Looking at the implementation, "ColumnMap" uses Map/Fold/MapAt, similar to wizard2. $\endgroup$
– Brett Champion
Commented Jul 22 at 15:48

Add a comment |

Stack Exchange Network

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

12 Answers 12

Your Answer

Not the answer you're looking for? Browse other questions tagged
list-manipulation
or ask your own question.

Linked

Hot Network Questions

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

12 Answers 12

Your Answer

Sign up or log in

Post as a guest

Not the answer you're looking for? Browse other questions tagged list-manipulation or ask your own question.

Linked

Related

Hot Network Questions

Not the answer you're looking for? Browse other questions tagged
list-manipulation
or ask your own question.