在Mathematica中，我如何为任意数量的参数编译Outer[]函数？

Question

在Mathematica中，我如何为任意数量的参数编译Outer[]函数？

compilationwolfram-mathematica

8

如果我想从两个列表list1和list2中找到所有可能的和，我使用Outer[]函数，并将Plus指定为组合运算符：

In[1]= list1 = {a, b}; list2 = {c, d}; Outer[Plus, list1, list2]

Out[1]= {{a + c, a + d}, {b + c, b + d}}

如果我想要处理任意数量的列表，例如一个列表的列表，

In[2]= listOfLists={list1, list2};

那么我知道如何找到所有可能的总和的唯一方法是使用Apply[]函数（它有简写@@）以及Join：

In[3]= argumentsToPass=Join[{Plus},listOfLists]

Out[3]= {Plus, {a, b}, {c, d}}

In[4]= Outer @@ argumentsToPass

Out[4]= {{a + c, a + d}, {b + c, b + d}}

或者只需

In[5]= Outer @@ Join[{Plus},listOfLists]

Out[5]= {{a + c, a + d}, {b + c, b + d}}

问题在于当我尝试编译时：

In[6]= Compile[ ..... Outer @@ Join[{Plus},listOfLists] .... ]

Compile::cpapot: "Compilation of Outer@@Join[{Plus},listOfLists]] is not supported for the function argument Outer. The only function arguments supported are Times, Plus, or List. Evaluation will use the uncompiled function. "

事实上，我正在使用支持的函数，即Plus。问题似乎仅与Apply[]函数有关。因为如果我给它一个固定数量的列表来outer-plus，它就可以正常工作

In[7]= Compile[{{bob, _Integer, 1}, {joe, _Integer, 1}}, Outer[Plus, bob, joe]]

Out[7]= CompiledFunction[{bob, joe}, Outer[Plus, bob, joe],-CompiledCode-]

但是一旦我使用Apply，它就会出错

In[8]= Compile[{{bob, _Integer, 1}, {joe, _Integer, 1}}, Outer @@ Join[{Plus}, {bob, joe}]]

Out[8]= Compile::cpapot: "Outer@@Join[{Plus},{bob,joe}]的编译不支持函数参数Outer。唯一支持的函数参数是Times、Plus或List。评估将使用未编译的函数。"

所以我的问题是：是否有一种方法可以规避这个错误，或者在编译函数中计算从任意数量的列表中提取的所有元素的可能总和的方法？

(另外，我不确定"compilation"是否是一个合适的标签。请给予指导。)

非常感谢。

- Jess Riedel

你预计会有多少个列表，每个列表的长度是多少？根据答案，编译可能不是执行此操作的最快方式。 - joebolte

2个回答

4

这是我的第一篇文章。希望我能做得好。

如果您的输入是整数列表，我对在Mathematica 7中编译此函数的价值持怀疑态度。

例如：

f = Compile[{{a, _Integer, 1}, {b, _Integer, 1}, {c, _Integer, 1}, {d, _Integer, 1}, {e, _Integer, 1}}, 
        Outer[Plus, a, b, c, d, e]
    ];

a = RandomInteger[{1, 99}, #] & /@ {12, 32, 19, 17, 43};

Do[f @@ a, {50}] // Timing

Do[Outer[Plus, ##] & @@ a, {50}] // Timing

对我来说，这两个时间并没有显著的区别，但当然这只是一个样本而已。重点仅在于与编译版本相比，Outer已经相当快了。

如果你除了速度之外还有其他编译原因，你可能会发现元组（Tuples）比Outer更有用，但你仍然需要遵守编译函数需要张量输入的限制。

f2 = Compile[{{array, _Integer, 2}}, 
      Plus @@@ Tuples@array
    ];

f2[{{1, 3, 7}, {13, 25, 41}}]

如果您的输入很大，那么可能需要采取不同的方法。给定一个整数列表的列表，此函数将返回可能的总和以及达到每个总和的方式数量:

f3 = CoefficientRules@Product[Sum[x^i, {i, p}], {p, #}] &;

f3[{{1, 3, 7}, {13, 25, 41}}]

在许多情况下，这应该能够证明更加节省内存。

a2 = RandomInteger[{1, 999}, #] & /@ {50, 74, 55, 55, 90, 57, 47, 79, 87, 36};

f3[a2]; // Timing

MaxMemoryUsed[]

这个操作只花费了3秒并且内存使用很少，但是当尝试将Outer应用于a2时，内核出现了“没有更多可用的内存”错误。

- Mr.Wizard

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- Leonid Shifrin · Accepted Answer

一种方法是使用With，以编程方式创建编译函数：

Clear[makeCompiled];
makeCompiled[lnum_Integer] :=
 With[{listNames = Table[Unique["list"], {lnum}]},
   With[{compileArgs = {#, _Integer, 1} & /@ listNames},
      Compile @@ Join[Hold[compileArgs],
        Replace[Hold[Outer[Plus, listNames]], 
          Hold[Outer[Plus, {x__}]] :> Hold[Outer[Plus, x]], {0}]]]];

可能有更优美的方法，但这个也可以。例如：

In[22]:= p2 = makeCompiled[2]
Out[22]= CompiledFunction[{list13,list14},Outer[Plus,list13,list14],-CompiledCode-]

In[23]:= p2[{1,2,3},{4,5}]
Out[23]= {{5,6},{6,7},{7,8}}

In[24]:= p3 = makeCompiled[3]
Out[24]= CompiledFunction[{list15,list16,list17},Outer[Plus,list15,list16,list17],-CompiledCode-]

In[25]:= p3[{1,2},{3,4},{5,6}]
Out[25]= {{{9,10},{10,11}},{{10,11},{11,12}}}

希望对你有帮助。

编辑:

你可以将编译后的函数隐藏在另一个函数后面，这样它会在运行时创建并且你实际上看不到它：

In[33]:= 
Clear[computeSums]
computeSums[lists : {__?NumberQ} ..] := makeCompiled[Length[{lists}]][lists];

In[35]:= computeSums[{1, 2, 3}, {4, 5}]

Out[35]= {{5, 6}, {6, 7}, {7, 8}}

在这种情况下，您面临编译的开销，因为您每次都会创建一个全新的编译函数。您可以通过记忆化（memoization）来优雅地解决这个问题，使用Module变量以实现持久性，将您的记忆化定义局部化：

In[44]:= 
Clear[computeSumsMemoized];
Module[{compiled},
  compiled[n_] := compiled[n] = makeCompiled[n];
  computeSumsMemoized[lists : {__?NumberQ} ..] := compiled[Length[{lists}]][lists]];

In[46]:= computeSumsMemoized[{1, 2, 3}, {4, 5}]

Out[46]= {{5, 6}, {6, 7}, {7, 8}}