【问题标题】:Prepend vs. Append perf in Mathematica在 Mathematica 中前置与附加性能
【发布时间】:2011-12-09 19:37:03
【问题描述】:

在类似 Lisp 的系统中,cons 是将元素添加到列表的常规方法。附加到列表的函数要昂贵得多,因为它们将列表遍历到末尾,然后将最终的 null 替换为对附加项的引用。 IOW(伪Lisp)

(prepend list item) = (cons item list) = cheap!
(append list item) = (cond ((null? list) (cons item null))
                           (#t (cons (car list (append (cdr list) item)))))

问题是 Mathemtica 中的情况是否类似?在大多数情况下,Mathematica 的列表似乎像 lisp 的列表一样是单链接的,如果是这样,我们可以假设 Append[list,item] 比 Prepend[list,item] 昂贵得多。但是,我无法在 Mathematica 文档中找到任何内容来解决这个问题。如果 Mathematica 的列表是双向链接的或更巧妙地实现,例如,在堆中或仅维护指向最后的指针,则插入可能具有完全不同的性能配置文件。

任何建议或经验将不胜感激。

【问题讨论】:

    标签: list wolfram-mathematica lisp


    【解决方案1】:

    Mathematica 的列表不像 Common Lisp 中的单链表。最好将数学列表视为数组或类似向量的结构。插入的速度是O(n),但检索的速度是恒定的。

    查看Data structures and Efficient Algorithms in Mathematica 中的page,它更详细地介绍了mathematica 列表。

    另外请查看this Stack Overflow 关于链表的问题及其在数学中的表现。

    【讨论】:

    • +1。只是为了补充这个很好的答案,Mathematica 列表作为数组实现这一事实具有非常深远的影响,影响到 Mathematica 编程的各个方面,从编程风格(基于规则、函数等)到性能调整。特别是,在编写任何对性能很重要的代码时,都应该清楚这一点。
    • 我认为虽然很遗憾 Mathematica 中缺少最重要的结构,即结构(或记录)。这使得在大型程序中管理数据变得很困难,当人们在函数之间传递很多东西时,因为不能在记录中排列相关数据,而不是传递单独的参数。对于小程序,这无关紧要。我看不出如果没有至少一个记录数据结构,如何设计非常大的程序。当前在 Mathematica 中模拟结构的所有解决方案都不能很好地工作。
    • @Nasser,这是你的结构:name[val11, val2,...] 写选择器 getVal1[a_name]:=a[[1]] 等等,然后你就去吧。 Mathematica 在很大程度上是用 Mathematica 编写的(大约 1MLOC)我认为这很大。
    • @rubenko,可以将这样的“结构”传递给编译函数吗?
    • @Nasser -- 我使用像记录这样的定义;我认为它们是哈希表或 JavaScript 对象。要在变量 r“内部”建模键值对,请执行以下操作 r["a"]=1;r[2]="b";用 ??r 报告所有值。检索类似 r["a"] 或 r[2] 的值。使用 r[foo]===r[foo] 检查键 foo 的值是否不存在。我已经用这个技巧编写了一个完整的记录处理库(或 k-v DB 库,如果你愿意的话)。可以轻松地与关联列表(k-v 对的显式列表)进行往返。稍后我会发布一个链接。
    【解决方案2】:

    作为一个小插件,这是 M- 中“AppendTo”的有效替代方法

    myBag = Internal`Bag[]
    Do[Internal`StuffBag[myBag, i], {i, 10}]
    Internal`BagPart[myBag, All]
    

    【讨论】:

    • 有没有办法使用Bag[] 实现堆栈?也就是说,我们可以pop一个包吗? (听起来很有趣……)
    • @ruebenko -- 我如何检查“内部”命名空间中的一些其他定义? ??Internal 和 ??Internal` 不起作用 :)
    • 据我所知这是不可能的。
    • @Reb.Cabin,您想使用?Internal`*,它会生成Context 中所有内容的列表。但是,它们没有记录,因此您只能找到它们的列表,而不是它们可以做什么。
    • 而且大部分东西都是无关紧要的,只有少数确实有外部用途。
    【解决方案3】:

    如前所述,由于 Mathematica 列表是作为数组实现的,因此 Append 和 Prepend 等操作会导致每次添加元素时都会复制列表。一种更有效的方法是预先分配一个列表并填充它,但是我下面的实验并没有显示出我预期的那么大的差异。显然,更好的是链表方法,我将不得不研究它。

    Needs["PlotLegends`"]
    test[n_] := Module[{startlist = Range[1000]},
       datalist = RandomReal[1, n*1000];
       appendlist = startlist;
       appendtime = 
        First[AbsoluteTiming[AppendTo[appendlist, #] & /@ datalist]];
       preallocatedlist = Join[startlist, Table[Null, {Length[datalist]}]];
       count = -1;
       preallocatedtime = 
        First[AbsoluteTiming[
          Do[preallocatedlist[[count]] = datalist[[count]]; 
           count--, {Length[datalist]}]]];
       {{n, appendtime}, {n, preallocatedtime}}];
    results = test[#] & /@ Range[26];
    ListLinePlot[Transpose[results], Filling -> Axis, 
     PlotLegend -> {"Appending", "Preallocating"}, 
     LegendPosition -> {1, 0}]
    

    比较 AppendTo 和预分配的时序图。 (运行时间:82 秒)

    编辑

    使用 nixeagle 建议的修改大大改善了预分配时间,即使用 preallocatedlist = Join[startlist, ConstantArray[0, {Length[datalist]}]];

    二次编辑

    {{{startlist},data1},data2} 形式的链表效果更好,并且具有不需要像预分配那样提前知道大小的巨大优势。

    Needs["PlotLegends`"]
    test[n_] := Module[{startlist = Range[1000]},
       datalist = RandomReal[1, n*1000];
       linkinglist = startlist;
       linkedlisttime = 
        First[AbsoluteTiming[
          Do[linkinglist = {linkinglist, datalist[[i]]}, {i, 
            Length[datalist]}];
          linkedlist = Flatten[linkinglist];]];
       preallocatedlist = 
        Join[startlist, ConstantArray[0, {Length[datalist]}]];
       count = -1;
       preallocatedtime = 
        First[AbsoluteTiming[
          Do[preallocatedlist[[count]] = datalist[[count]]; 
           count--, {Length[datalist]}]]];
       {{n, preallocatedtime}, {n, linkedlisttime}}];
    results = test[#] & /@ Range[26];
    ListLinePlot[Transpose[results], Filling -> Axis, 
     PlotLegend -> {"Preallocating", "Linked-List"}, 
     LegendPosition -> {1, 0}]
    

    链表与预分配的时间比较。 (运行时间:6 秒)

    【讨论】:

    • 至少在 Mathematica 8 上,通过将 Table[Null, {Length[datalist]}] 更改为 ConstantArray[0, {Length[datalist]}],我获得了 巨大 的性能改进,由此产生的行为至少是一个命令大输入的速度要快得多,并反映了预期的算法复杂性。
    • 改进来自用 0 替换 Null。preallocatedlist = Join[startlist, Table[0, {Length[datalist]}]] 提供相同的性能改进
    • Table Null 和 Table 0 在 v7 中都非常快,比上面第一个图中显示的要快得多。 ConstantArray 还是要快一些。似乎在 v8 中引入了关于 Table[Null, {x}] 的大幅减速。
    • 以上内容仍有待改进。你正在混合类型。 startlist 是整数,而 data list 是实数。您可以添加一个 Developer`ToPackedArray@Flatten[linkinglist] 以获得后续的乐趣。另请注意,预分配列表未打包。 cou-- 不需要。使用 Do[bla;bla,{count, Length[],1}]。将它与上面显示的包进行比较也很好。
    • 进一步的评论 - 我看到代码使用某种附加功能。当然,在某些情况下这是正确的做法。我发现稍微考虑一下这个问题并查看是否可以预先计算大小并执行矢量化 Set a la data=ConstantArray[0,{..}] data[[pos]]=vals.
    【解决方案4】:

    如果您知道您的结果将包含多少个元素并且您可以计算您的元素,那么整个 Append、AppendTo、Linked-List 等就没有必要了。在 Chris 的速度测试中,预分配只起作用,因为他事先知道元素的数量。对 datelist 的访问操作代表对当前元素的虚拟计算。

    如果情况是这样,我永远不会使用这种方法。一个简单的 Table 与一个 Join 相结合的速度更快。让我重用 Chris 的代码:我将预分配添加到时间测量中,因为在使用 Append 或链表时,也会测量内存分配。此外,我真的使用结果列表并检查它们是否相等,因为聪明的解释器可能会识别简单、无用的命令并优化它们。

    Needs["PlotLegends`"]
    test[n_] := Module[{
        startlist = Range[1000],
        datalist, joinResult, linkedResult, linkinglist, linkedlist, 
        preallocatedlist, linkedlisttime, preallocatedtime, count, 
        joinTime, preallocResult},
    
    
       datalist = RandomReal[1, n*1000];
       linkinglist = startlist;
       {linkedlisttime, linkedResult} = 
        AbsoluteTiming[
         Do[linkinglist = {linkinglist, datalist[[i]]}, {i, 
           Length[datalist]}];
         linkedlist = Flatten[linkinglist]
         ];
    
       count = -1;
       preallocatedtime = First@AbsoluteTiming[
          (preallocatedlist = 
            Join[startlist, ConstantArray[0, {Length[datalist]}]];
           Do[preallocatedlist[[count]] = datalist[[count]];
            count--, {Length[datalist]}]
           )
          ];
    
       {joinTime, joinResult} =
        AbsoluteTiming[
         Join[startlist, 
          Table[datalist[[i]], {i, 1, Length[datalist]}]]];
       PrintTemporary[
        Equal @@@ Tuples[{linkedResult, preallocatedlist, joinResult}, 2]];
       {preallocatedtime, linkedlisttime, joinTime}];
    
    results = test[#] & /@ Range[40];
    ListLinePlot[Transpose[results], PlotStyle -> {Black, Gray, Red}, 
     PlotLegend -> {"Prealloc", "Linked", "Joined"}, 
     LegendPosition -> {1, 0}]
    

    在我看来,有趣的情况是,当您事先不知道元素的数量并且您必须临时决定是否必须附加/前置某些内容时。在这些情况下, Reap[] 和 Sow[] 可能值得一看。一般来说,我会说,AppendTo 是邪恶的,在使用它之前,看看替代方案:

    n = 10.^5 - 1;
    res1 = {};
    t1 = First@AbsoluteTiming@Table[With[{y = Sin[x]},
          If[y > 0, AppendTo[res1, y]]], {x, 0, 2 Pi, 2 Pi/n}
         ];
    
    {t2, res2} = AbsoluteTiming[With[{r = Release@Table[
            With[{y = Sin[x]},
             If[y > 0, y, Hold@Sequence[]]], {x, 0, 2 Pi, 2 Pi/n}]},
        r]];
    
    {t3, res3} = AbsoluteTiming[Flatten@Table[
         With[{y = Sin[x]},
          If[y > 0, y, {}]], {x, 0, 2 Pi, 2 Pi/n}]];
    
    {t4, res4} = AbsoluteTiming[First@Last@Reap@Table[With[{y = Sin[x]},
            If[y > 0, Sow[y]]], {x, 0, 2 Pi, 2 Pi/n}]];
    
    {res1 == res2, res2 == res3, res3 == res4}
    {t1, t2, t3, t4}
    

    给出 {5.151575, 0.250336, 0.128624, 0.148084}。构造

    Flatten@Table[ With[{y = Sin[x]}, If[y > 0, y, {}]], ...]
    

    幸运的是,它确实可读且速度快。

    备注

    在家里尝试最后一个例子时要小心。在这里,在我的 Ubuntu 64 位和 Mma 8.0.4 上,n=10^5 的 AppendTo 占用 10GB 内存。 n=10^6 占用我所有 32GB 的 RAM 来创建一个包含 15MB 数据的数组。好笑。

    【讨论】:

      猜你喜欢
      • 2011-05-15
      • 1970-01-01
      • 2011-05-09
      • 2012-02-25
      • 1970-01-01
      • 2011-07-03
      • 2017-04-19
      • 1970-01-01
      • 1970-01-01
      相关资源
      最近更新 更多