Wolfram mathematica 这有标准的功能吗？

Mathematica中可能有内置函数或更好更快的方法来实现这一点

func[l_, g_, f_] := g @@ f @@@ Transpose[{Most[l], Rest[l]}]

可以用来做这样的事情

l = {a, b, c, d}
func[l, Plus, (#1 - #2)^2 &]

我不知道这种函数的正确名称。折叠拉链类型的东西

更新 有很多解决方案。谢谢大家

使用

Partition[l, 2, 1] 

而不是

Transpose[{Most[l], Rest[l]}] 

这肯定会让事情更清楚

我尝试对函数运行计时，但得到了奇怪的结果：

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

func1[l，g，f]：=g@@f@@转置[{Most[l]，Rest[l]}]
func2[l，g，f]：=g@@f@@@Partition[l，2，1]
func3[l，g，f]：=g@@listcolvalve[{1，1}，l，{-1，1}，{}，Times，f]
func4[l_u2;，g_2;，f_2;]：=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]：=内部[f，序列@分区[l，长度[l]-1，1]，g]
func8[l，g，f]：=g@@MapThread[f，Partition[l，Length[l]-1，1]]
函数={func1，func2，func3，func4，func5，func6，func7，func8}
input=Table[ToExpression[“x”ToString[i]，{i，110000}]；
输入=表[Take[input，i*100000]，{i，1，10}]；
桌子[
如果[i==j==0，“，
如果[j==0，函数[[i]]，
如果[i==0，则长度[输入[[j]]]，
定时[功能[[i]][输入[[j]]][[1]]]，
{i，0，Length[functions]}，{j，0，Length[inputs]}]//转置//TableForm

每当你看到像

f@@@Transpose[{args}]

这样的东西时，你应该想到

Thread[]

。这一点在会议上进行了讨论

所以我能做的就是

func[l_, g_, f_] := g @@ Thread[f[Most[l], Rest[l]]]

---

但是Most[l]，Rest[l]结构仍然显得丑陋和低效。也许有一种更有效的方法可以做到这一点，但也许这是Mathematica中最简洁的方法。

如果你想要一种完全复制你的

函数功能的东西，我能想到的唯一的预类型化就是用
分区替换
转置[Most[l]，Rest[l]
：

func2[l_,g_,f_]:=g@@f@@@Partition[l,2,1]

如果你真的想要一些“内置”的东西，你可以在一些
listcolvalve
上下功夫

func3[l_,g_,f_]:=g@@ListConvolve[{1,1},l,{-1,1},{},Times,f]

检查所有这些工作是否正常：

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}

最后，如果这是您想要的答案，我建议您通过
Total[Differences[l]^2]

Out[14]= (-a+b)^2+(-b+c)^2+(-c+d)^2 

相当于（不是说更好）：

或者几乎

      func[l_, g_, f_] := g @@ f /@ Partition[l, 2, 1]

但最后一个需要

      func[l, Plus, (#[[1]] + #[[2]])^2 &]

这显然是低劣的
我认为这只是一个广义内积（广义点积），对
转置
/
大多数
/
剩余
位进行模化，所以你也可以使用：

还有，为了完整起见，我提到：

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

如果您总是从列表中找出差异，
差异
或
列表卷积
可能会更快，正如其他人所提到的

像Perl一样，在
Mathematica也是，你的问题的所有答案都表明了这一点
 这不是一个答案，而是一个更好的时间安排的建议。这个

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

将快速计算平均运行时间，例如

timeAvg@func1[l, Plus, (#1 - #2)^2 &]

为
l
尝试不同的长度会得到以下结果
其中N是
l
中的元素数
Thread[]
无疑是赢家。
感谢您指出
Thread
——尽管我确实喜欢
@@@@code>。至于
Transpose[Most，Rest]
要做的事情是使用
Partition
@Janus Partition[l，Length@l-1，1]={Most，Rest}@Janus
Partition
仍然复制初始数据，这是我主要关心的。你用
列表卷积
或
差异
的解决方案解决了这个问题。@belisarius这里的竞争真激烈！通常，我不会看到问题，直到它们出现在我的RSS提要中。这一次我上网了，你还是比我快了1分钟@西蒙，安静！马克斯事先发了电子邮件问这个问题！一套不错的选择<代码>差异
是
列表卷积
的一个特殊应用程序，因此它不需要像
分区
和
大多数，其余
那样复制列表。因此，它的内存效率应该更高。它也比我的解决方案快了大约1/3。@Simon但是OP指向了连续列表元素的一般功能。只是一个OT注释。要生成大列表
输入
使用
表[Symbol[“x”ToString[i]]、{i，1000000}]
或
数组[Symbol[“x”ToString[#]]和1000000]
比
ToExpression[…]更快。
 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};

timeAvg@func1[l, Plus, (#1 - #2)^2 &]