# How to Map a subset of list elements to a function?

How would you, given a list {1, 2, 3, 4}, apply a function f to 1 and 2, then 2 and 3, etc.?

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


More generally, how do you define which parts of a list you want to pass/Map/Apply to a function that takes multiple arguments?

• Thank you and a big thanks to everyone who contributed alternative solutions as well. – Teo Sartori Apr 9 '12 at 20:28

You might first partition your list and then use Map as usual :

f[#[[1]], #[[2]]] & /@ Partition[{1,2,3,4}, 2, 1]

(* {f[1, 2], f[2, 3], f[3, 4]} *)

• Excellent, that works. – Teo Sartori Apr 9 '12 at 14:43
• why is it f[#[[1]], #[[2]]] and not just f[#1,#2]? – Eiyrioü von Kauyf Apr 10 '12 at 0:58
• f[#1, #2] & @@@ Partition[{1,2,3}, 2, 1] – Per Alexandersson Apr 10 '12 at 7:40
• @PerAlexandersson f @@ Partition is enough/ – Kuba Jan 21 '15 at 10:49
• @Kuba you mean f @@@ Partition[{1,2,3,4}, 2, 1]. – Chip Hurst Dec 20 '17 at 18:05

Update: in version 10.2 BlockMap was added as a System context function.

If the arguments are sequential there is a function DeveloperPartitionMap that does this directly, potentially saving considerable memory over Partition.

DeveloperPartitionMap[f @@ # &, Range@5, 2, 1]

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


Syntax is the same as for Partition but with the function to map inserted as the first argument. Notice in my use above that I needed Apply (short form @@) to pass the elements as arguments rather than a single list.

If the arguments are not sequental you can use Part:

list = {a, b, c, d, e};

parts = {{1, 2}, {4, 1, 3}, {5, 2}};

f @@ list[[#]] & /@ parts

{f[a, b], f[d, a, c], f[e, b]}


You can use

f @@@ Partition[{1,2,3,4}, 2, 1]


which will give

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

• And this one is nice and short. – Teo Sartori Apr 9 '12 at 14:44

MapThread:

MapThread[g, #] &@{Most@#, Rest@#} &@{r, s, t, u, v, w}


{g[r, s], g[s, t], g[t, u], g[u, v], g[v, w]}

or,

MapThread[g, #] &@Transpose@Partition[#, 2,1] &@{r, s, t, u, v, w}


{g[r, s], g[s, t], g[t, u], g[u, v], g[v, w]}

which allows more flexibility to specify the lists to thread over, like:

MapThread[g, #] &@Transpose@Partition[#, 3, 2, 1] &@{r, s, t, u, v, w}


{g[r, s, t], g[s, t, u], g[t, u, v], g[u, v, w]}

Inner:

With last argument set to List gives the same result as MapThread:

Inner[g, Sequence @@ #, List] &@Transpose@Partition[#, 2, 1] &@{r, s,t, u, v, w}


{g[r, s], g[s, t], g[t, u], g[u, v], g[v, w]}

Thread:

Thread[g[Most@#, Rest@#]] &@{r, s, t, u, v, w};
Thread[g[Sequence @@ #]] &@({Most@#, Rest@#} &@{r, s, t, u, v, w});
Thread[g[Sequence @@ #]] &@(Transpose@Partition[#, 2, 1] &@{r, s, t,u, v, w});


From docs on Thread:

Functions with attribute Listable are threaded automatically over lists.

Hence for Listable functions, e.g., for h in the following example:

SetAtrributes[h, Listable];
h[Sequence @@ #] &@(Transpose@Partition[#, 2, 1] &@{r, s, t, u, v, w})


gives the same result as does

Thread[h[Sequence @@ #]] &@(Transpose@Partition[#, 2, 1] &@{r, s, t, u, v, w}).


Also from docs:

MapThread takes the function and its arguments separately.

Thread evaluates the whole expression before threading.

Hence, using MapThread is "safer" as pointed out in Mr.Wizard's comments.

Timings:

Test data:

 tsts = Table[RandomInteger[1000, 1000000], {10}];


Results table (apologies for not figuring out how to apply Thread in the following):

Grid[{{"method", "timing"},
{HoldForm[Thread[g[Sequence @@ #]] &@(Transpose@Partition[#, 2, 1] &)],
Table[AbsoluteTiming[ClearSystemCache[];
Thread[g[Sequence @@ #]] &@ (Transpose@Partition[#, 2, 1] &@ tsts[[i]])][[1]],
{i, 1, 10}] // Mean},
Table[AbsoluteTiming[ClearSystemCache[];
Thread[g[Most@#, Rest@#]] &@tsts[[i]]][[1]], {i, 1, 10}] //  Mean},
Table[AbsoluteTiming[ClearSystemCache[];
MapThread[g, Transpose@Partition[#, 2, 1]] &@tsts[[i]]][[1]], {i, 1, 10}] // Mean},
Table[AbsoluteTiming[ClearSystemCache[];
MapThread[g, {Most@#, Rest@#}] &@tsts[[i]]][[1]], {i, 1, 10}] //  Mean},
{HoldForm[Inner[g, Sequence @@ #, List] &@{Most@#, Rest@#} &],
Table[AbsoluteTiming[ClearSystemCache[];
Inner[g,Sequence @@ #,List] &@{Most@#,Rest@#} &@tsts[[i]]][[1]], {i, 1, 10}] // Mean},
{HoldForm[Inner[g, Sequence @@ #, List] &@Transpose@Partition[#, 2, 1] &],
Table[AbsoluteTiming[ClearSystemCache[];
Inner[g, Sequence @@ #, List] &@Transpose@Partition[#, 2, 1] &@
tsts[[i]]][[1]], {i, 1, 10}] // Mean},
{HoldForm[DeveloperPartitionMap[g @@ # &, tsts[[i]], 2, 1]],
Table[AbsoluteTiming[ClearSystemCache[];
DeveloperPartitionMap[g @@ # &, tsts[[i]], 2, 1]][[1]], {i, 1, 10}] // Mean},
{HoldForm[g @@@ Partition[tsts[[i]], 2, 1]],
Table[AbsoluteTiming[ClearSystemCache[];
g @@@ Partition[tsts[[i]], 2, 1]][[1]], {i, 1, 10}] // Mean},
{HoldForm[ g @@@ Most[{tsts[[i]], RotateLeft@tsts[[i]]}\[Transpose]]],
Table[AbsoluteTiming[ClearSystemCache[];
g @@@ Most[{tsts[[i]], RotateLeft@tsts[[i]]}\[Transpose]]][[1]], {i, 1, 10}] // Mean},
{HoldForm[Fold[(Sow[g[#1, #2]]; #2) &, First@#, Rest@#] &@tsts[[i]]; //
Reap // Last],
Table[AbsoluteTiming[ClearSystemCache[];
Fold[(Sow[g[#1, #2]]; #2) &, First@#, Rest@#] &@tsts[[i]]; //
Reap // Last][[1]], {i, 1, 10}] // Mean},
{HoldForm[g[#[[1]], #[[2]]] & /@ Partition[tsts[[i]], 2, 1]],
Table[AbsoluteTiming[ClearSystemCache[];
g[#[[1]], #[[2]]] & /@ Partition[tsts[[i]], 2, 1]][[1]], {i, 1, 10}] // Mean}},
Frame -> All]


Timing results:

• Probably too specific since the OP was asking "generally" but if you expand this answer to address Listable functions and discuss the performance benefits you'll heartily earn my +1. – Mr.Wizard Apr 9 '12 at 15:03
• @Mr.Wizard I like this one, and it's the type of thing I often use as I didn't know about DeveloperPartition until very recently. – rcollyer Apr 9 '12 at 15:11
• @rcollyer I like this one a lot too (hence: "heartily") but the answer is unfinished. Thread as shown is dangerous because of evaluation order, and the most elegant an efficient possibility (with Listable functions) is neither shown nor explained. – Mr.Wizard Apr 9 '12 at 15:13
• @Mr.Wizard How is Thread dangerous? I don't see it. I also, don't see the answer as being incomplete. Instead, I see it as not being generalizable, e.g. what if the OP wanted to expand it to sequential, overlapping triples, instead? – rcollyer Apr 9 '12 at 15:20
• @Mr.Wizard well with Listable functions neither Thread nor MapThread are necessary, e.g. Block[{f}, SetAttributes[f, Listable]; f[Most@#, Rest@#] &@{1, 2, 3}]. Setting f = Print is an interesting counter argument. I'm still parsing it. My Listable example doesn't function as expected with Print, either. – rcollyer Apr 9 '12 at 15:46

Mathematica 10 introduced MovingMap and operator forms:

MovingMap[Apply[f], Range @ 9, 2]

{f[1, 2], f[2, 3], f[3, 4], f[4, 5], f[5, 6], f[6, 7], f[7, 8], f[8, 9]}


Useful information: Mathematica periodic moving map

In Mathematica 10.1 the syntax for MovingMap changed; now you must use:

MovingMap[Apply[f], Range @ 9, 1]

{f[1, 2], f[2, 3], f[3, 4], f[4, 5], f[5, 6], f[6, 7], f[7, 8], f[8, 9]}

• There's also ListCorrelate[{1, 1}, Range@9, {1, -1}, {}, Times, f] – LLlAMnYP May 12 '15 at 9:01
• @LLlAMnYP My update is not intended to preclude that; please post that as an answer if you would like. – Mr.Wizard May 12 '15 at 9:03
• it's on my mind right now, as I'm reflecting on a question of mine about mapping to a subsequence of a list (generalization to multidimensional lists in a different way, than suggested before). I'm surprised, it didn't show up in the answers, as it's around since v.4, but I'm reluctant to post it, when there are now several functions in v.10 that do specifically the required thing. – LLlAMnYP May 12 '15 at 9:20
• @LLlAMnYP I see no reason not to post it; not only are backward-compatible methods of use to many people but alternative methods can often be adapted in ways that built-ins cannot. Incidentally ListCorrelate did get a mention in my answer to a more recent and related question. – Mr.Wizard May 12 '15 at 9:35

Update: A function f can be mapped to partition elements using f as the undocumented 6th argument of Partition.

Partition[{1, 2, 3, 4}, 2, 1, {1, -1}, {}, f]


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

Partition[{1, 2, 3, 4}, 2, 1, {1, -1}, {}, Plus]


{3, 5, 7}

Partition[Range[10], 5, 2, None, {}, Mean[{##}] &]


{3, 5, 7}

Also works with ragged partitions if f is defined for sequences of varying length:

{Partition[Range[5], 5, 2, {-1, 1}, {}],
Partition[Range[5], 5, 2, {-1, 1}, {}, foo],
Partition[Range[5], 5, 2, {-1, 1}, {}, Plus]} // Column // TeXForm


$\begin{array}{l} \{\{1\},\{1,2,3\},\{1,2,3,4,5\},\{3,4,5\},\{5\}\} \\ \{\text{foo}(1),\text{foo}(1,2,3),\text{foo}(1,2,3,4,5),\text{foo}(3,4,5),\text{foo}(5)\} \\ \{1,6,15,12,5\} \\ \end{array}$

Original post:

List @@ Partition[f[1, 2, 3, 4], 2, 1]


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

And yet another one:

list = Range[5];

f @@@ Most[{list, RotateLeft@list}\[Transpose]]

(*
==> {f[1, 2], f[2, 3], f[3, 4], f[4, 5]}
*)


It's strange, that ListCorrelate has not been mentioned, according to the documentation, it has been around unchanged since v.4.0. It allows a one liner:

ListCorrelate[{1, 1}, Range@9, {1, -1}, {}, Times, f]
(* {f[1, 2], f[2, 3], f[3, 4], f[4, 5], f[5, 6], f[6, 7], f[7, 8], f[8, 9]} *)
ListConvolve[{1, 1}, Range@9, {-1, 1}, {}, Times, f]
(* {f[1, 2], f[2, 3], f[3, 4], f[4, 5], f[5, 6], f[6, 7], f[7, 8], f[8, 9]} *)


ListConvolve, as you can see, acts in a very similar manner. Their drawback is, they necessarily move along the list in steps of one. A result like

(* {f[1, 2, 3], f[3, 4, 5], f[5, 6, 7], f[7, 8, 9]} *)


does not appear to be possible(?)

I would probably use DeveloperPartitionMap, but here's an approach using Fold, Reap and Sow just to demonstrate the various ways of doing the same thing:

list = {1, 2, 3, 4};
Fold[(Sow[f[#1, #2]]; #2) &, First@#, Rest@#] &@ list; // Reap // Last
(* Out[1]= {{f[1, 2], f[2, 3], f[3, 4]}} *)

 MapIndexed[f[#1, list[[#2[[1]] + 1]]] &, Most@list]


or

f @@ RotateLeft[list, #][[1 ;; 2]] & /@ Range[0, Length[list] - 2]