Wolfram 语言与系统参考资料中心

RecurrenceTable

RecurrenceTable[eqns,expr,{n,n_max}]

以求解递归方程 eqns 为基础，产生一组关于连续 n 的 expr 的值的列表.

RecurrenceTable[eqns,expr,nspec]

在 nspec 指定的 n 值范围上，产生一组 expr 的值.

RecurrenceTable[eqns,expr,{n₁,…},{n₂,…},…]

为连续的 n₁，n₂，… 产生 expr 的数组值.

范例

打开所有单元关闭所有单元

基本范例 (4)

对于一阶递归方程，求解一个初值问题：

Wolfram Language code: RecurrenceTable[{a[n + 1] == 3a[n], a[1] == 7}, a, {n, 1, 10}]

求解前几个斐波纳契数：

Wolfram Language code:

RecurrenceTable[{a[n] == a[n - 1] + a[n - 2], a[1] == 1, a[2] == 1}, a, 
  {n, 10}]

Wolfram Language code: Table[Fibonacci[n], {n, 10}]

求解平面的一个非线性映射的解：

Wolfram Language code:

RecurrenceTable[{x[n + 1] == 0.7x[n] + y[n], 
    y[n + 1] == -0.7989995 + x[n] ^ 2, x[0] == 0.142857, y[0] == 0.33}, {x, y}, {n, 1, 2500}]//Short

Wolfram Language code: ListPlot[%, PlotRange -> All]

计算第一类 Stirling 数的表：

Wolfram Language code:

RecurrenceTable[{s1[n, k] == s1[n - 1, k  - 1] - (n - 1)s1[n  - 1, k], 
    s1[0, k] == KroneckerDelta[k]}, s1, {n, 0, 6}, {k, 0, 4}]//Grid

Wolfram Language code: Table[StirlingS1[n, k], {n, 0, 6}, {k, 0, 4}]//Grid

范围 (12)

普通微分方程 (6)

有精确系数的线性普通微分方程：

Wolfram Language code: RecurrenceTable[{a[n + 2] == 3n a[n + 1] + 5a[n], a[1] == 1, a[2] == 1}, a, {n, 1, 10}]

有不精确系数的非线性普通微分方程：

Wolfram Language code: RecurrenceTable[{a[n] == 1.3a[n - 2] ^ 2 + 5.2a[n - 1], a[1] == 1, a[2] == 2}, a, {n, 1, 6}]

有符号初值条件的普通微分方程组：

Wolfram Language code:

RecurrenceTable[{2 x[n + 1] + Mod[n, 5] ^ 2 y[n] == n, 5 x[n] - y[n + 1] == 7, x[1] == a, y[1] == b}, {x, y}, {n, 1, 3}]//Together

仅返回 x 的值：

Wolfram Language code:

RecurrenceTable[{2 x[n + 1] + Mod[n, 5] ^ 2 y[n] == n, 5 x[n] - y[n + 1] == 7, x[1] == a, y[1] == b}, x, {n, 1, 3}, DependentVariables -> {x, y}] // Together

用精确算法的迭代：

Wolfram Language code: RecurrenceTable[{x[n + 1] == (7/2)x[n](1 - x[n]), x[0] == (1/3)}, x, {n, 10}]

从精度 20 开始，用相应的算法迭代：

Wolfram Language code: RecurrenceTable[{x[n + 1] == (7/2)x[n](1 - x[n]), x[0] == N[(1/3), 20]}, x, {n, 10}]

每次迭代，精度递减：

Wolfram Language code: ListPlot[Map[Precision, %]]

用固定的 20 位精度算法迭代：

Wolfram Language code: RecurrenceTable[{x[n + 1] == (7/2)x[n](1 - x[n]), x[0] == (1/3)}, x, {n, 10}, WorkingPrecision -> 20]

用机器算法迭代：

Wolfram Language code: RecurrenceTable[{x[n + 1] == (7/2)x[n](1 - x[n]), x[0] == (1/3)}, x, {n, 10}, WorkingPrecision -> MachinePrecision]

通过给出一个向量的初始条件，迭代多个值：

Wolfram Language code:

Grid[Partition[Map[ListPlot[#, DataRange -> {0, 1}, PlotStyle -> PointSize[0.01]]&, RecurrenceTable[{x[n + 1] == .9 Sin[π x[n]], x[0] == N[Range[0, 1000] / 1000]}, x, {n, 0, 8}]], 3]]

迭代一个矩阵递归：

Wolfram Language code:

Map[MatrixForm, RecurrenceTable[{m[k + 1] == m[k].(|    |    |
| -- | -- |
| .1 | 1  |
| 0  | .1 |).m[k], m[0] == (|   |    |
| - | -- |
| 0 | -1 |
| 1 | 0  |)}, m, {k, 3}]]

偏微分方程 (2)

对于二项系数，用偏微分递归方程：

Wolfram Language code:

RecurrenceTable[{binomial[n, k] == binomial[n - 1, k] + binomial[n - 1, k - 1], binomial[0, k] == KroneckerDelta[k]}, binomial, {n, 0, 8}, {k, 0, 8}]//Grid

一个非线性偏微分方程的过程解：

Wolfram Language code: RecurrenceTable[{f[n, k] == f[n - 1, k] ^ 2 + n ^ 2f[n - 1, k - 1], f[0, k] == 3k + 1.}, f, {n, 0, 20}, {k, 0, 20}];

Wolfram Language code: MatrixPlot[Log[1 + Abs[%]]]

差分-代数方程 (1)

求解有常系数的一个线性差分-代数方程：

Wolfram Language code:

sol1 = RecurrenceTable[{y[n + 1] + z[n + 1] == y[n] - 3z[n] + 7, y[n] + 2z[n] == 1, y[0] == 1 / 2, z[0] == 1 / 4}, {y, z}, {n, 0, 4}]//Quiet

与 RSolve 给出的符号解比较：

Wolfram Language code: RSolve[{y[n + 1] + z[n + 1] == y[n] - 3z[n] + 7, y[n] + 2z[n] == 1, y[0] == 1 / 2, z[0] == 1 / 4}, {y, z}, n]

Wolfram Language code: sol2 = Table[{y[n], z[n]} /. %[[1]], {n, 0, 4}]

系统模型 (3)

状态空间模型对采样正弦信号的状态响应和输出响应：

Wolfram Language code:

sr = RecurrenceTable[Sin[t] -> StateSpaceModel[{{{0, 1}, {-0.5, 1.5}}, {{0}, {1}}, {{0, 1}}, {{0}}}, SamplingPeriod -> 1, 
 SystemsModelLabels -> None], "StateResponse", {t, 0, 15}]

Wolfram Language code: ListStepPlot[sr, DataRange -> {0, 15}]

Wolfram Language code:

or = RecurrenceTable[Sin[t] -> StateSpaceModel[{{{0, 1}, {-0.5, 1.5}}, {{0}, {1}}, {{0, 1}}, {{0}}}, SamplingPeriod -> 1, 
 SystemsModelLabels -> None], "OutputResponse", {t, 0, 15}]

Wolfram Language code: ListStepPlot[or, DataRange -> {0, 15}]

初始条件为 {1,-1} 的离散时间系统的状态响应：

Wolfram Language code:

sr = RecurrenceTable[{Sin[t] -> StateSpaceModel[{{{0.9418, 0.2462}, {-0.2462, 0.3262}}, {{0.1958}, {-0.0291}}, {{2, 1}}, {{0}}}, 
 SamplingPeriod -> 0.2, SystemsModelLabels -> None], {1, -1}}, "StateResponse", {t, 0, 10}]

Wolfram Language code: ListStepPlot[sr, DataRange -> {0, 10 0.2}]

两个输入的系统的输出响应：

Wolfram Language code:

or = RecurrenceTable[{Sin[k], Cos[k]} -> TransferFunctionModel[{{{z, -0.1 + z}, {1, 4}}, 
  {{-0.5 + z, 0.5 + z}, {-0.5 + z, 0.5 + z}}}, 
 z, SamplingPeriod -> 0.1], "OutputResponse", {k, 0, 3}]

Wolfram Language code: ListStepPlot[or, DataRange -> {0, 3 0.1}]

推广和延伸 (3)

从给出的范围，产生一个子集：

Wolfram Language code: RecurrenceTable[{a[n] == a[n - 1] + a[n - 2], a[1] == 1, a[2] == 1}, a, {n, 1, 15}]

Wolfram Language code: RecurrenceTable[{a[n] == a[n - 1] + a[n - 2], a[1] == 1, a[2] == 1}, a, {n, 1, 15, 2}]

仅给出迭代的最后的值：

Wolfram Language code: Timing[First[RecurrenceTable[{x[n + 1] == π Sin[π x[n]], x[0] == .1}, x, {n, 10 ^ 6, 10 ^ 6}]]]

当所有值保存时，这样的速度会更快：

Wolfram Language code: Timing[Last[RecurrenceTable[{x[n + 1] == π Sin[π x[n]], x[0] == .1}, x, {n, 10 ^ 6}]]]

用一个向量的初始条件：

Wolfram Language code: RecurrenceTable[{x[n + 1] == π Sin[π x[n]], x[0] == Range[0, 1, .1]}, x, {n, 5}]

选项 (3)

DependentVariables (1)

当您仅需要保存某些值时，用 DependentVariables 指定变量：

Wolfram Language code:

RecurrenceTable[{x[n + 2] == y[n], y[n + 1] == -x[n], x[0] == 1, x[1] == 0, y[0] == 0}, x, {n, 0, 3}, DependentVariables -> {x, y}]

仅 y 保存：

Wolfram Language code:

RecurrenceTable[{x[n + 2] == y[n], y[n + 1] == -x[n], x[0] == 1, x[1] == 0, y[0] == 0}, y, {n, 0, 3}, DependentVariables -> {x, y}]

按顺序 {y,x} 保存：

Wolfram Language code:

RecurrenceTable[{x[n + 2] == y[n], y[n + 1] == -x[n], x[0] == 1, x[1] == 0, y[0] == 0}, {y, x}, {n, 0, 3}, DependentVariables -> {x, y}]

Method (1)

用 Method->{Compiled->False} 避免使用 Wolfram 语言编译：

Wolfram Language code:

m = 10 ^ 6;
reqn = {x[n + 1] == Nest[(4 #(1 - #))&, x[n], 2], x[0] == .314}

Wolfram Language code: Timing[Last[compiled = RecurrenceTable[reqn, x, {n, m}]]]

Wolfram Language code: Timing[Last[justrun = RecurrenceTable[reqn, x, {n, m}, Method -> {Compiled -> False}]]]

优化的算法变化，结果不同：

Wolfram Language code: ListPlot[Take[Abs[compiled - justrun], 50], PlotRange -> All]

WorkingPrecision (1)

对于更快速迭代，用 WorkingPrecision->MachinePrecision：

Wolfram Language code: reqn = {x[n + 1] == (9 / 5)If[x[n] < 1 / 2, x[n], 1 - x[n]], x[0] == 1 / 3};

Wolfram Language code: Timing[Mean[RecurrenceTable[reqn, x, {n, 10 ^ 6}, WorkingPrecision -> MachinePrecision]]]

对于较慢速迭代，用 WorkingPrecision->p，但迭代的精度更高：

Wolfram Language code: Timing[Mean[RecurrenceTable[reqn, x, {n, 10 ^ 6}, WorkingPrecision -> 50]]]

精确计算没有误差，但可能更慢：

Wolfram Language code: Timing[Mean[RecurrenceTable[reqn, x, {n, 10 ^ 4}]];]

应用 (6)

对数方程 (1)

对于参数 r 的不同值，研究对数方程的行为：

Wolfram Language code: Table[ListPlot@RecurrenceTable[{y[n + 1] == r y[n](1 - y[n]), y[0] == 1 / 3}, y, {n, 1, 600}], {r, 3.0, 3.6, 0.2}]

随机数产生 (1)

执行 Cliff 随机数产生：

Wolfram Language code: RecurrenceTable[{x[n + 1] == Abs[Mod[100Log[x[n]], 1]], x[0] == 0.1}, x, {n, 0, 4}]

随机数显示统一分布：

Wolfram Language code: RecurrenceTable[{x[n + 1] == Abs[Mod[100Log[x[n]], 1]], x[0] == 0.1}, x, {n, 1, 1000}]//ListPlot

对于统一分布，比较参数：

Wolfram Language code: t = RecurrenceTable[{x[n + 1] == Abs[Mod[100Log[x[n]], 1]], x[0] == 0.1}, x, {n, 1, 10 ^ 5}];

Wolfram Language code: ({Mean[#1], Variance[#1], Skewness[#1], Kurtosis[#1]} & )[t]

Wolfram Language code: N[({Mean[#1], Variance[#1], Skewness[#1], Kurtosis[#1]} & )[UniformDistribution[{0, 1}]]]

兔形 (1)

绘制 Douady 兔子形状：

Wolfram Language code: c = -0.122561 + 0.744862I;

初始条件，在矩形的每个方向有 250 个点，其中矩形有角度和：

Wolfram Language code: zinit = Table[a + I b, {a, -1.3, 1.3, 2.6 / 249}, {b, -1.3, 1.3, 2.6 / 249}];

从几个初始条件开始的迭代：

Wolfram Language code: Timing[iterates = RecurrenceTable[{z[k + 1] == z[k] ^ 2 + c, z[0] == zinit}, z, {k, 0, 20}];]

用 ArrayPlot 显示形状：

Wolfram Language code: data = Map[If[Max[Abs[#]] ≤ 2, 1, 0]&, Flatten[iterates, {{2}, {3}, {1}}], {2}];

Wolfram Language code: ArrayPlot[data]

对数映射的分岔图 (1)

对于的1000个值，求出从映射的和的迭代：

Wolfram Language code:

k = 1000; r = Range[3., 4., 1 / (k - 1)];
rhs[x_ ? VectorQ] := r x(1 - x);

Wolfram Language code:

iterates = RecurrenceTable[{x[n + 1] == rhs[x[n]], x[0] == ConstantArray[1. / π, k]}, x, {n, 10 ^ 4, 2 10 ^ 4}];//Timing

缩放迭代到位于 1 和之间的整数，并颠倒顺序，这样行对应于：

Wolfram Language code: data = Transpose[Ceiling[iterates k]];

定义一个函数，给出基于每个值统计算法的规则：

Wolfram Language code:

count[data_, i_] := Module[{c, j}, 
	{j, c} = Transpose[Tally[data]];
	Transpose[{j, ConstantArray[i, Length[j]]}] -> Log[N[c]]];

制作一个稀疏矩阵，将统计应用 Count 到每个的迭代上：

Wolfram Language code: S = SparseArray[Table[count[data[[i]], i], {i, k}], k]

用 ArrayPlot 制作分叉图表：

Wolfram Language code: ArrayPlot[Reverse[S], ColorFunction -> "Rainbow"]

比较常微分方程数值方法 (1)

对于，欧拉方法是无条件不稳定的：

Wolfram Language code:

ListPlot[Block[{h = .1}, RecurrenceTable[
	{x[n + 1] == x[n] + h y[n], x[0] == 1.0, 
	y[n + 1] == y[n] - h Sin[x[n]], y[0] == 0.}, 
	{x, y}, {n, 0, 300}]]]

偶对的欧拉方法是稳定的，但在较大 h 下，对于初始条件是敏感的：

Wolfram Language code:

se[h_, {x0_, y0_}]  := RecurrenceTable[
	{x[n + 1] == x[n] + h y[n], x[0]  == x0, 
	y[n + 1] == y[n] - h Sin[x[n] + h y[n]], y[0] == y0}, 
	{x, y}, {n, 0, 500}];ListPlot[{se[.1, {2.67, 0.}], se[1., {2.67, 0.}], se[1., {2.66, 0.}]}]

比较有 Manipulate 的不同向量域的方法：

Wolfram Language code:

Manipulate[
	Block[{n, f1, f2, rhs, req, vfn}, 
	vfn = vf  /. {x -> x[n], y -> y[n]};
	If[method === "Euler", 
	rhs = {x[n], y[n]} + h * vfn, 
	f1 = x[n] + h * First[vfn];
	f2 = y[n] + h * (Last[vfn] /. x[n] -> f1);
	rhs = {f1, f2}];
	req = Thread[{x[n + 1], y[n + 1]} == rhs];
	ListPlot[RecurrenceTable[{req /. h -> hh, Thread[{x[0], y[0]} == p]}, {x, y}, {n, 0, Ceiling[10 ^ ls]}], PlotRange -> {{-4, 4}, {-3, 3}}, PlotLabel -> ToString[req, TraditionalForm]]], 
	{{p, {2.67, 0}}, Locator}, {{ls, 4, "SubscriptBox[log, 10](SubscriptBox[n, max])"}, 1, 6}, {{hh, 1., "StepSize"}, 10 ^ -4, 2}, {{vf, {y, -Sin[x]}, "Vector Field"}, {{y, -x}, {y, -Sin[x]}, {y, x * (1 - x ^ 2)}}, ControlType -> PopupMenu}, {method, {"SymplecticEuler", "Euler"}}]

标准映射 (1)

对于一列初始条件，由标准映射导致的延伸和折叠 [更多信息]:

Wolfram Language code:

Block[{k = 1, m = 10000}, Grid[Partition[MapIndexed[Tooltip[ListPlot[Transpose[#1], PlotStyle -> PointSize[0.01], PlotRange -> {{0, 2π}, {-2.5, 2.5}}], n == First[#2] - 1]&, RecurrenceTable[{
	x[n + 1] == Mod[y[n] + x[n] + k Sin[x[n]], 2π], x[0] == ConstantArray[N[π], m], y[n + 1] == y[n]  + k Sin[x[n]], y[0] == N[2 Range[m] / (m)]}, 
	{x, y}, {n, 0, 11}]], 3]]]

属性和关系 (3)

RSolve 对于这个递归方程，求出一个符号解：

Wolfram Language code: RSolve[{a[n + 1] == 2a[n] + 1, a[0] == 7}, a, n]

Wolfram Language code: Table[a[n] /. %[[1]], {n, 0, 7}]

RecurrenceTable 对于相同问题，产生一个过程解：

Wolfram Language code: RecurrenceTable[{a[n + 1] == 2a[n] + 1, a[0] == 7}, a, {n, 0, 7}]

使用 RecurrenceFilter 对信号滤波：

Wolfram Language code: RecurrenceFilter[{{1, -(1/2)}, {1}}, {1, 0, 0, 0, 0, 0, 0, 0}]

使用 RecurrenceTable 获得相同结果：

Wolfram Language code: RecurrenceTable[{y[n] - (1/2)y[n - 1] == DiscreteDelta[n], y[-1] == 0}, y[n], {n, 0, 7}]

用 RFixedPoints 求非线性递归方程的不动点：

Wolfram Language code: RFixedPoints[x[n + 1] == (1/2)x[n](1 - x[n]), x, n]

用 RStabilityConditions 分析不动点的稳定性：

Wolfram Language code: RStabilityConditions[x[n + 1] == (1/2)x[n](1 - x[n]), x, n]

用 RecurrenceTable 解方程：

Wolfram Language code: sol = RecurrenceTable[{x[n + 1] == (1/2)x[n](1 - x[n]), x[0] == -9 / 10}, x, {n, 0, 20}, WorkingPrecision -> 10]

绘制解：

Wolfram Language code: ListPlot[sol, PlotRange -> All]

巧妙范例 (1)

可视化显示热方程的初始数据的平滑：

Wolfram Language code: c = 1; k = 1 / 320; h = 0.08;

Wolfram Language code:

sol = RecurrenceTable[{v[i, j] == c((1 - (2 k) / h ^ 2)v[i, j - 1] + (k(v[i + 1, j - 1] + v[i - 1, j - 1])) / h ^ 2), 
     v[i, 0] == UnitStep[2. - i h]UnitStep[i h + 2]100}, v, {i, -70, 70}, {j, 0, 300}];

Wolfram Language code: Table[ListLinePlot[Transpose[sol][[i]], Filling -> Axis, Ticks -> None], {i, {1, 20, 100, 300}}]

Wolfram Language code: ListPlot3D[Transpose[sol], Mesh -> None, PlotStyle -> {Orange, Specularity[White, 10]}]

Top

DependentVariables	Automatic	所有独立变量的列表
Method	Automatic	使用的方法
WorkingPrecision	Automatic	内部计算使用的精度

	"StateResponse"	sys 对输入的状态响应
	"OutputResponse"	sys 对输入的输出响应

RecurrenceTable

更多信息和选项

范例

基本范例 (4)

范围 (12)

普通微分方程 (6)

偏微分方程 (2)

差分-代数方程 (1)

系统模型 (3)

推广和延伸 (3)

选项 (3)

DependentVariables (1)

Method (1)

WorkingPrecision (1)

应用 (6)

对数方程 (1)

随机数产生 (1)

兔形 (1)

对数映射的分岔图 (1)

比较常微分方程数值方法 (1)

标准映射 (1)

属性和关系 (3)

巧妙范例 (1)

参见

相关指南

相关链接

历史

文本

CMS

APA

BibTeX

BibLaTeX