Mapping multiple functions over an array

Question

I am looking for an elegant way to Map multiple functions over an array. My problem looks something like this:

Consider a list of functions:

f = {f1,f2,f3,f4} (* example, can be larger *)

And an array:

A = {{a1, b1, c1, d1, e1}, {a2, b2, c2, d2, e2}, {a3, b3, c3, d3, e3}}; (*example, can be larger*)

Q1: I’d like to map the functions in f over the array A so that the final result looks like:

B= {{1 - a1, f1[a1]*b1, f2[a1]*c1, f3[a1]*d1, f4[a1]*e1}, {1 - a2, 
f1[a2] b2, f2[a2] c2, f3[a2] d2, f4[a2] e2}, {1 - a3, f1[a3] b3, 
f2[a3] c3, f3[a3] d3, f4[a3] e3}}

Q2: How do I map the functions a little differently so that the output looks like:

c= {{a1, f1[a1] b1, f2[b1] c1, f3[c1] d1, f4[d1] e1}, {a2, f1[a2] b2, 
f2[b2] c2, f3[c2] d2, f4[d2] e2}, {a3, f1[a3] b3, f2[b3] c3, 
f3[c3] d3, f4[d3] e3}} // tf

Answer 1

Here's a way to write out the map concisely:

Q1:

{1 - #, ##2} Through[Join[{1 &}, f]@#] & @@@ A
(* {{1 - a1, b1 f1[a1], c1 f2[a1], d1 f3[a1], e1 f4[a1]}, 
    {1 - a2, b2 f1[a2], c2 f2[a2], d2 f3[a2], e2 f4[a2]}, 
    {1 - a3, b3 f1[a3], c3 f2[a3], d3 f3[a3], e3 f4[a3]}} *)

Q2:

Join[{1 - #[[1]]}, MapThread[#3 #@#2 &, {f, Most@#, Rest@#}]] & /@ A
(* {{1 - a1, b1 f1[a1], c1 f2[b1], d1 f3[c1], e1 f4[d1]}, 
    {1 - a2, b2 f1[a2], c2 f2[b2], d2 f3[c2], e2 f4[d2]}, 
    {1 - a3, b3 f1[a3], c3 f2[b3], d3 f3[c3], e3 f4[d3]}} *)

Answer 2

I was thinking about a more readable way because your question under rm's answer

Any take on Q2 above?

slightly indicates that you couldn't take it further although the idea to solve Q2 was similar. I guess my solution is in no way as easy as I had hoped it to be, but I give it anyway.

What it does is that it separates the tasks a bit. The distributor takes your list of functions and exactly one sublist like e.g. {a1, b1, c1, d1, e1} and builds up the result. For your Q1 this is just calculating 1-a1 and creating all the x1*fn[a1].

distributor[funcs_][vec_] :=
 Join[{1 - First[vec]}, #2*#1[First[vec]] & @@@ Transpose[{funcs, Rest[vec]}]
  ]

And now you can map the distributor over your A

distributor[f] /@ A

To solve your second problem Q2 you only need to adjust the distributor which now includes a call to Partition to create sequence {{a1, b1}, {b1, c1}, {c1, d1}, {d1, e1}} we need:

distributor2[funcs_][vec_] :=
 Join[{1 - First[vec]}, #2[[2]]*#1[#2[[1]]] & @@@ Transpose[{funcs, Partition[vec, 2, 1]}]
  ]

distributor2[f] /@ A