制作表格的速度差异

Question

我正在阅读a useful post at WRI blog on improving speed of code，我需要帮助来理解这一点。

比较这些速度

Timing[
 tbl = Table[i + j, {i, 1, 1000}, {j, 1, 1000}];     
]

{0.031, Null}

和

Timing[
 a = 1000;
 tbl = Table[i + j, {i, 1, a}, {j, 1, a}];
 ]

{0.422, Null}

因此，将限制的实际值放入表本身与外部相比要快得多。对此的解释，我确信它是正确的，但我需要帮助理解，是 Table 如果其限制是数字而不是非数字，则编译，这是因为它的属性是 HoldAll。

但我的问题是：上述内容实际上如何工作，因为Table 的限制必须在某一时刻变成数字？我不会写

Clear[a]
tbl = Table[i + j, {i, 1, a}, {j, 1, a}]

上面给出了一个错误。

所以，对我来说，在Table 和内部写a=1000 应该没有区别，因为没有a 有一个数值，Table[] 不能做任何事情。因此，在 Table[] 可以做任何有用的事情之前，评估者必须在某个时间点将 a 替换为数字 1000，不是吗？

换句话说，Table 在这两种情况下最终应该看到的是{i, 1, 1000}, {j, 1, 1000}。

所以，我认为这会发生的方式是这样的：

1. Evaluator 将表参数中的 a 替换为 1000
2. 评估员调用 Table 并得到结果，现在全是数字。
3. Table 已编译，现在运行速度更快。

但似乎发生的事情是另一回事。 （由于HoldAll？）

1. 表按原样接受它的参数。因为它有 HoldAll，所以它看到 a 而不是 1000。
2. 它不调用 Compile，因为它的参数并非全是数字。
3. 它现在生成一个带有 a 限制的表，Evaluator 将 a 评估为 1000
4. 现在已生成表，所有限制都是数字，但现在速度较慢，因为未编译代码。

问题是：会发生上述情况吗？有人能解释一下解释这种时间差异的步骤吗？

另外，在上面的例子中，如何确保 Table 在两种情况下都被编译，即使使用一个变量作为限制？并非总是可以硬编码表格限制的数字，但有时必须为这些数字使用变量。是否应该明确使用Compile 命令？ （我不直接使用Compile，因为我认为它是在需要时自动完成的。

编辑(1)

在下面 Mike 发表的关于使用呼叫时发现时间没有差异的回答中。

ClearAll[tblFunc];
Timing[a = 1000;
 tblFunc[a_] := Table[i + j, {i, 1, a}, {j, 1, a}];
 Developer`PackedArrayQ[tblFunc[a]]
 ]

给予

{0.031, True}

但那是因为a 现在是函数内部的数字1000，一旦它被调用。由于 M 通过 VALUE 传递事物。

如果我们强制调用是通过引用进行的，这样a 就不会被评估，那么我们得到

ClearAll[tblFunc];
Timing[a = 1000;
 tblFunc[a_] := Table[i + j, {i, 1, a}, {j, 1, a}];
 Developer`PackedArrayQ[tblFunc[Unevaluated@a]]
 ]

现在我们看到了预期的结果，因为现在a 在函数内部仍然是符号，我们回到第一方，现在它很慢，因为没有打包。而且由于没有打包，所以没有使用Compile。

{0.437, False}

编辑(2) 感谢大家的回答，我想我从他们那里学到了分配。

这是一个执行摘要，只是为了确保我一切正常。

编辑(3)

以下是我专门提供的与使 Mathematica 代码运行得更快的提示相关的链接。

1. http://library.wolfram.com/howtos/faster/
2. http://blog.wolfram.com/2011/12/07/10-tips-for-writing-fast-mathematica-code/
3. https://stackoverflow.com/questions/4721171/performance-tuning-in-mathematica
4. Using Array and Table Functions in Mathematica. Which is best when

Answer 1

所以这就是我认为正在发生的事情。您看到Table 上的数字和符号限制之间速度变慢的原因是您执行了双索引。每个子表（例如，遍历所有索引 j 以获得固定索引 i）是单独构建的，当限制是符号时，在构建每个子表之前需要一个额外的步骤来确定该限制。您可以通过检查来看到这一点，例如

Trace[a = 3;
      tbl = Table[i + j, {i, 1, a}, {j, 1, a}];
     ]

David 提供了一个很好的示例，说明您为什么要对每个子列表进行此检查。至于为什么 Mathematica 无法弄清楚何时不需要此检查，我不知道。如果你只有一个索引来求和，那么符号版本和数字版本之间的速度没有区别

Timing[tbl = Table[i + j, {j, 1, 1000}];]
{0.0012, Null}

Timing[a = 1000;
       tbl = Table[i + j, {j, 1, a}];
      ]
{0.0013, Null}

回答您对速度的跟进；使tbl 成为一个函数对于数字和符号限制都更快。

Timing[a = 1000;
       tblFunc[a_] := Table[i + j, {i, 1, a}, {j, 1, a}];
       tblFunc[a];
      ]

{0.045171, Null}

对比

Timing[tbl = Table[i + j, {i, 1, 1000}, {j, 1, 1000}];]
{0.066864, Null}

Timing[a = 1000;
       tbl = Table[i + j, {i, 1, a}, {j, 1, a}];
      ]
{0.632128, Null}

如果您打算重用 tbl 构造，您将获得更快的速度。

b=1000;
Timing[tblFunc[b];]
{0.000013, Null}

Answer 2

正如其他人所提到的，要监控的关键事项是包装和清单长度。我实际上没有看到 Timo 报告的差异：

ClearAll[tblFunc];
Timing[a = 1000;
 tblFunc[a_] := Table[i + j, {i, 1, a}, {j, 1, a}];
 Developer`PackedArrayQ[tblFunc[a]]]

{0.077706, True}

vs

ClearAll[tbl];
Timing[
 tbl = Table[i + j, {i, 1, 1000}, {j, 1, 1000}];
 Developer`PackedArrayQ[tbl]]

{0.076661, True}

ClearAll[tbl];
Timing[a = 1000;
 tbl = Table[i + j, {i, 1, a}, {j, 1, a}];
 Developer`PackedArrayQ[tbl]]

{1.02879, False}

所以对我来说，唯一的区别是列表是否已打包。它是否是一个功能对我的设置时间没有影响。正如预期的那样，当您关闭自动编译时，上述所有时间都相同，因为没有发生打包：

SetSystemOptions["CompileOptions" -> {"TableCompileLength" -> Infinity}];

{1.05084, False}

vs

{1.00348, False}

{1.01537, False}

重置表自动编译长度：

SetSystemOptions["CompileOptions" -> {"TableCompileLength" -> 250}]

Answer 3

这有点 OT，但为了速度，您可能希望避免使用使用 Table 时隐含的逐项处理。相反，使用外部。这是我在系统上看到的内容：

   Timing[Outer[Plus, Range[5000], Range[5000]];]
{0.066763,Null}

   Timing[Table[i + j, {i, 1, 5000}, {j, 1, 5000}];]
{0.555197,Null}

相当大的差异。