Is there a standard function for this? - wolfram-mathematica

Question

There is probably built-in function or a better and faster way to do this in Mathematica
func[l_, g_, f_] := g ## f ### Transpose[{Most[l], Rest[l]}]
which can be used to do things like this
l = {a, b, c, d}
func[l, Plus, (#1 - #2)^2 &]
I don't know the proper name for this kind of function. Something in a fold-zip genre.
UPDATE
Lot's of solutions. Thanks to everyone.
Using
Partition[l, 2, 1]
instead of
Transpose[{Most[l], Rest[l]}]
definitely makes it clearer.
I've tried to run timings on the functions, but I get strange results:
func1[l_, g_, f_] := g ## f ### Transpose[{Most[l], Rest[l]}]
func2[l_, g_, f_] := g ## f ### Partition[l, 2, 1]
func3[l_, g_, f_] := g ## ListConvolve[{1, 1}, l, {-1, 1}, {}, Times, f]
func4[l_, g_, f_] := g ## Thread[f[Most#l, Rest#l]]
func5[l_, g_, f_] := g ## f /# Partition[l, 2, 1]
func6[l_, g_, f_] := g ## Thread[f[Most[l], Rest[l]]]
func7[l_, f_, g_] := Inner[f, Sequence ## Partition[l, Length[l] - 1, 1], g]
func8[l_, g_, f_] := g ## MapThread[f, Partition[l, Length[l] - 1, 1]]
functions = {func1, func2, func3, func4, func5, func6, func7, func8}
input = Table[ToExpression["x" <> ToString[i]], {i, 1, 1000000}];
inputs = Table[Take[input, i*100000], {i, 1, 10}];
Table[
If[i == j == 0, "",
If[j == 0, functions[[i]],
If[i == 0, Length[inputs[[j]]],
Timing[functions[[i]][inputs[[j]]]][[1]]]]],
{i, 0, Length[functions]}, {j, 0, Length[inputs]}] // Transpose // TableForm

Answer 1

If you want something that exactly duplicates the functionality of your func, the only prettyfication I can think of is replacing Transpose[Most[l],Rest[l]] with Partition:
func2[l_,g_,f_]:=g##f###Partition[l,2,1]
If you really want something "built in", you could hack on some ListConvolve for kicks
func3[l_,g_,f_]:=g##ListConvolve[{1,1},l,{-1,1},{},Times,f]
Checking that all these work:
Through[{func,func2,func3}[l,Plus,(#1-#2)^2&]]
Out[19]= {(a-b)^2+(b-c)^2+(c-d)^2,(a-b)^2+(b-c)^2+(c-d)^2,(a-b)^2+(b-c)^2+(c-d)^2}
Finally, if this is the answer you are looking for, I would suggest computing it by Total[Differences[l]^2]
Out[14]= (-a+b)^2+(-b+c)^2+(-c+d)^2

Answer 2

Whenever you see something like f###Transpose[{args}] you should think of Thread[]. This was discussed in The semantics of Mathematica's Thread function.
So the best I could do was
func[l_, g_, f_] := g ## Thread[f[Most[l], Rest[l]]]
but the Most[l], Rest[l] construction still seems ugly and inefficient. There is probably a more efficient way to do it - but maybe this is as compact as it can get in Mathematica.

Answer 3

Equivalent to (not saying it's better):
func[l_, g_, f_] := g ## Thread[f[Most#l, Rest#l]]
Or almost
func[l_, g_, f_] := g ## f /# Partition[l, 2, 1]
But this last one needs
func[l, Plus, (#[[1]] + #[[2]])^2 &]
Which is clearly inferior

Answer 4

This is not an answer but a suggestion for a better timing routine. This
timeAvg[func_] := Module[{
x = 0, y = 0, timeLimit = 0.1, p, q,
iterTimes = Power[10, Range[0, 10]]},
Catch[
If[(x = First[Timing[(y++; Do[func, {#}]);]]) > timeLimit,
Throw[{x, y}]
] & /# iterTimes
] /. {p_, q_} :> p/iterTimes[[q]]
];
Attributes[timeAvg] = {HoldAll};
will calculate an average run time quite quickly, e.g.,
timeAvg#func1[l, Plus, (#1 - #2)^2 &]
Trying out different lengths for l gives the following result
where N is the number of elements in l. Thread[] is the clear winner.

Answer 5

I think that's just an generalized inner product (generalized dot product), modulo the Transpose/Most/Rest bit, so you could also just use Inner:
func[lis_, f_, g_] := Inner[f, Sequence##Partition[list, Length[lis]-1, 1], g]
In[90]:= func[l,Plus,(#-#2)^2&]
Out[90]= (a - b)^2 + (b - c)^2 + (c - d)^2
There's also MapThread, which I mention for completeness:
func2[lis_, g_, f_] := g ## MapThread[f, Partition[lis, Length[lis]-1, 1]]
In[94]:= func2[l, Plus, (# - #2)^2 &]
Out[94]= (a - b)^2 + (b - c)^2 + (c - d)^2
If you're always making differences out of the list, Differences or ListConvolve could be faster, as others have mentioned.
Like Perl, TMTOWTDI in
Mathematica too, as all the answers to your question show!