【问题标题】:How to improve ( mathematica ) performance when dealing with recursive functions?处理递归函数时如何提高(数学)性能?
【发布时间】:2011-09-01 09:38:14
【问题描述】:

背景。我想打印一张 31^(1/2) 的收敛表。我对表进行了以下递归定义。 (用黄金比例交换 31^(1/2) 和下表将包含斐波那契数列)。

 cf := ContinuedFraction
 tf := TableForm
 p[-1] = 0; p[0] = 1; q[-1] = 1; q[0] = 0;
 a[k_] := cf[Sqrt[31], k][[k]]
 p[k_] := a[k]*p[k - 1] + p[k - 2]
 q[k_] := a[k]*q[k - 1] + q[k - 2]
 s[n_] := Timing[Table[{k, a[k], p[k], q[k]}, {k, 8, 8 n, 8}]] // tf

时间呈指数级增长。我不得不alt +。 (中止)为 s[4]。

问题:在处理递归函数时如何提高 (mathematica) 性能?

【问题讨论】:

标签: algorithm wolfram-mathematica


【解决方案1】:

快速(承认这一点并不彻底)查看您的代码,看起来p 和q 都是根据两个 以前的值递归定义的。这意味着要计算p 的nth 值,需要~2^n 评估(每一步都会使数字翻倍)。所以,是的,无论使用 Mathematica 或任何其他语言,复杂性都是指数级的。

如果您坚持使用问题的递归公式(例如,为了简单起见),那么减少性能损失的最简单方法是使用memoization,即执行类似

p[k_] := p[k] = a[k]*p[k - 1] + p[k - 2]

在重新定义之前不要忘记Clear[p]。

简而言之,memoization 意味着让函数记住每个输入的计算结果,因此后续评估更快。从前两个值(p_(n) 和 p_(n-1))计算 两个 值(p_(n+1) 和 p_(n))很可能更快,但更复杂,那么复杂度将是线性的而不是指数的。

我希望这会有所帮助。我现在没有 Mathematica 来测试。

【讨论】:

  • +1 用于记忆,尽管我怀疑寻找一个迭代解决方案来解决您的问题是非常值得的。例如对于斐波那契数列,从底部开始构建比使用递归(即使使用记忆)要快得多。
  • @Tuskan360,当然,这更快(另见我的编辑)。关键是记忆对现有实现的最小修改,使性能非常有用。 “迭代”解决方案相当于使用成对的值进行计算(如我的编辑中所示)。这可以使用递归、Nest 或过程编程来完成。
  • @Szabolcs - 效果很好! s[4] 从分钟减少到毫秒。
【解决方案2】:

这是一个小的进一步改进。由于这是一个二次无理数,您还可以更直接地计算 a[k] 系数。

In[499]:= Clear[a, p, q, cf]
cf = ContinuedFraction[Sqrt[31]];
cf2len = Length[cf[[2]]];
a[1] = cf[[1]];
a[k_] := cf[[2, Mod[k - 1, cf2len, 1]]]
p[-1] = 0; p[0] = 1; q[-1] = 1; q[0] = 0;
p[k_] := p[k] = a[k]*p[k - 1] + p[k - 2]
q[k_] := q[k] = a[k]*q[k - 1] + q[k - 2]
s[n_] := Timing[Table[{k, a[k], p[k], q[k]}, {k, 8, 8 n, 8}];]

In[508]:= s[1000]

Out[508]= {0.12, Null}

In[509]:= Clear[a, p, q, cf]
cf := ContinuedFraction
p[-1] = 0; p[0] = 1; q[-1] = 1; q[0] = 0;
a[k_] := a[k] = cf[Sqrt[31], k][[k]]
p[k_] := p[k] = a[k]*p[k - 1] + p[k - 2]
q[k_] := q[k] = a[k]*q[k - 1] + q[k - 2]
s[n_] := Timing[Table[{k, a[k], p[k], q[k]}, {k, 8, 8 n, 8}];]

In[516]:= s[1000]

Out[516]= {6.08, Null}

你也可以得到一个封闭形式的 a[k],虽然它不是很漂亮。

In[586]:= Clear[a];
asoln[k_] = 
 FullSimplify[
  a[k] /. First[
    RSolve[Join[
      Table[a[k] == cf[[2, Mod[k - 1, cf2len, 1]]], {k, 
        cf2len}], {a[k] == a[k - 8]}], a[k], k]], Assumptions -> k > 0]

Out[587]= (1/(8*Sqrt[2]))*(4*(Cos[(k*Pi)/4] + Sin[(k*Pi)/4])*
        (-2*Sqrt[2] + (5 + 2*Sqrt[2])*Sin[(k*Pi)/2]) + 
      Sqrt[2]*(25 - 9*Cos[k*Pi] + 26*Sin[(k*Pi)/2] - 9*I*Sin[k*Pi]))

临时我不知道这是否可以用来得到 p[k] 和 q[k] 的直接解。 RSolve 似乎无法做到这一点。

--- 编辑---

正如其他人所提到的,从头到尾构建列表会更简洁。这是 p[k] 的处理,使用上面的 memoization vs NestList。

Clear[a, p, q, cf]
cf = ContinuedFraction[Sqrt[31]];
cf2len = Length[cf[[2]]];
a[1] = cf[[1]];
a[k_] := cf[[2, Mod[k - 1, cf2len, 1]]]

p[-1] = 0; p[0] = 1;
p[k_] := p[k] = a[k]*p[k - 1] + p[k - 2]
s[n_] := Timing[Table[p[k], {k, n}];]

In[10]:= s[100000]

Out[10]= {1.64, Null}

In[153]:= s2[n_] := Timing[ll = Module[{k = 0},
      NestList[(k++; {#[[2]], a[k]*#[[2]] + #[[1]]}) &, {0, 1}, 
       n]][[All, 2]];]

In[154]:= s2[100000]

Out[154]= {0.78, Null}

除了稍微快一些之外,第二种方法不会保留大量定义。而且您并不真的需要它们来生成更多元素,因为可以使用来自最后一个元素的一对来恢复此迭代(确保它们从 0 和 1 模 8 开始)。

我会提到可以得到 p[k] 的封闭形式。我发现将解决方案分成 8 个(即 cf2len)块并通过重复链接它们很方便。幕后的推理来自基本的生成函数操作。我对一个方程和一个初始条件做了一些稍微特殊的处理,以巧妙地处理 a[1] 不是重复序列的一部分这一事实。

In[194]:= func = Array[f, cf2len];
args = Through[func[n]];
firsteqns = {f[2][n] == a[2]*f[1][n] + f[cf2len][n - 1], 
   f[1][n] == a[9]*f[cf2len][n - 1] + f[cf2len - 1][n - 1]};
resteqns = 
  Table[f[j][n] == a[j]*f[j - 1][n] + f[j - 2][n], {j, 3, cf2len}];
inits = {f[8][0] == 1, f[1][1] == 5};
eqns = Join[firsteqns, resteqns, inits];

In[200]:= 
soln = FullSimplify[args /. First[RSolve[eqns, args, n]], 
   Assumptions -> n > 0];

In[201]:= FullSimplify[Table[soln, {n, 1, 3}]]

Out[201]= {{5, 6, 11, 39, 206, 657, 863, 1520}, {16063, 17583, 33646, 
  118521, 626251, 1997274, 2623525, 4620799}, {48831515, 53452314, 
  102283829, 360303801, 1903802834, 6071712303, 7975515137, 
  14047227440}}

快速检查:

In[167]:= s2[16]; ll

Out[167]= {1, 5, 6, 11, 39, 206, 657, 863, 1520, 16063, 17583, 33646, \
118521, 626251, 1997274, 2623525, 4620799}

我们现在可以由此定义一个函数。

In[165]:= 
p2[k_Integer] := soln[[Mod[k, cf2len, 1]]] /. n -> Ceiling[k/cf2len]

In[166]:= Simplify[p2[4]]

Out[166]= 39

我并没有声称这特别有用,只是想看看我是否真的可以做点什么。

---结束编辑---

丹尼尔·利希特布劳

【讨论】:

  • 用递归/生成函数为 a[k] 创建一个封闭形式是一个绝妙的主意。迄今为止,在有关连分数的文献中从未见过它。
  • @nilo 我猜你的意思是 p[k]。 a[k](忽略第一个元素)的递归很简单,因为它是一个重复序列:a[k] = a[k-8]。生成函数并不难获得。我使用的符号应该是 Sum[x^k*cf[[2, k]]/(1 - x^cf2len), {k, cf2len}]。但我无法找到一种方法来使用它来获取 p 或 q 作为生成函数。
  • p[k]。当然。 - 好吧,概括了 sqrt[n] 的连分数的收敛序列,与用 N 中的 (x,y) 求解 pell 方程 x^2-n*y^2=1 相关。 - 有趣的话题。如果我没有那么多竞争活动,我可以花几个月的时间。 ;-) 我刚刚发现这个顺便说一句。不确定它是否相关。 cecm.sfu.ca/personal/pborwein/PAPERS/P68.pdf -
猜你喜欢
  • 2017-11-21
  • 1970-01-01
  • 2017-10-22
  • 2021-02-07
  • 2011-12-22
  • 1970-01-01
  • 1970-01-01
  • 2014-09-20
  • 1970-01-01
相关资源
最近更新 更多