预测一个数列的极限

KeyTo9_Fans

已知一数列$\{A_n\}$具有某种规律，

当$n->\infty$时收敛于极限$c$，

并且知道前$18$项的近似值（小数点后$14$位有效）：

$A_1=0.5000000000000000$
$A_2=0.5411961001461970$
$A_3=0.5592963160013235$
$A_4=0.5697241339680272$
$A_5=0.5758100732116277$
$A_6=0.5797027571324435$
$A_7=0.5823512950800830$
$A_8=0.5842414664898477$
$A_9=0.5856415568613965$
$A_10=0.5867100340534064$
$A_11=0.5875456013767071$
$A_12=0.5882124706064433$
$A_13=0.5887539536513828$
$A_14=0.5892001711937236$
$A_15=0.5895726247096161$
$A_16=0.5898870137232585$
$A_17=0.5901550299615904$
$A_18=0.5903855332606833$

能否根据这些值预测当$n->\infty$时，极限$c$的值？

精确程度可以达到几位小数？

用什么方法预测？

wayne

这跟看序列找规律区别不大吧，呵呵

KeyTo9_Fans

好像是的。

拿个什么函数拟合一下，然后根据函数表达式求极限。

wayne

我猜测，A2的准确值应该是
$1/{\sqrt{2+\sqrt{2}}}$

wayne

老大，能否说说这道题的背景

wayne

看成是曲线拟合的话，会忽视掉 题干给的高精度的信息。
我感觉应该有一种预测方法，比曲线拟合更强的方法，要不插值试试.......

wayne

关于外插方法，推荐你一本书：
Practical Extrapolation Methods: Theory and Applications
书里面开篇就谈到了问题背景：


下载地址：
http://ifile.it/d5x87go/0521661595.rar

Buffalo

http://mathworld.wolfram.com/WynnsEpsilonMethod.html

wayne

8# Buffalo
呵呵，你给的方法我那本书里面大篇幅介绍了

KeyTo9_Fans

我自己设计了一个很土的方法，预测出了一个极限值：

$lim_{n->\infty}A_n=0.592746063$

$c++$代码如下：

1. #include<cstdio>
   
2. #include<math.h>
   
3. 
   
4. double a[999999]={0,
   
5. 0.5,
   
6. 0.54119610014619698439972320536639,
   
7. 0.55929631600132353475576392078938,
   
8. 0.56972413396802715322804051835303,
   
9. 0.57581007321162765360503297431458,
   
10. 0.57970275713244352141943997833056,
    
11. 0.58235129508008298007347469183041,
    
12. 0.58424146648984767386035113239817,
    
13. 0.58564155686139651141699566635464,
    
14. 0.58671003405340635980469047312441,
    
15. 0.58754560137670707686509637674778,
    
16. 0.58821247060644326317197307974183,
    
17. 0.58875395365138276709785553207334,
    
18. 0.58920017119372364434464005947868,
    
19. 0.58957262470961612944817110769224,
    
20. 0.5898870137232585,
    
21. 0.5901550299615904,
    
22. 0.5903855332606833};
    
23. 
    
24. int i;
    
25. double b[999999],c[999999],d[999999],e[999999];
    
26. 
    
27. double f(int i) //f(i)是二次函数(a+bi+ci^2)的倒数，a、b、c的值是根据误差最小的原则拟合出来的。
    
28. {
    
29.         return 1/(51.339415-11.69409*i+0.64923801*i*i);
    
30. }
    
31. 
    
32. int main()
    
33. {
    
34.         for(i=1;i<19;i++)
    
35.         {
    
36.                 b[i]=exp(-log(a[i]-a[i-1])*4/11);        //将a数列的相邻两项作差，将差的(-4/11)次方记为b数列
    
37.                 if(i>1)c[i]=b[i]-b[i-1];        //将b数列的相邻两项作差，记为c数列
    
38.         }
    
39.         for(i=3;i<19;i++)
    
40.         {
    
41.                 d[i]=exp(-log(c[i-1]-c[i])*4/10);                //将c数列的相邻两项作差，将差的(-4/10)次方记为d数列
    
42.                 if(i>3)e[i]=d[i]-d[i-1];        //将d数列的相邻两项作差，记为e数列
    
43.         }
    
44.         for(i=5;i<19;i++)
    
45.         {
    
46.                 if(i>5)printf("%d %.16lf %.16lf\n",i,e[i]-e[i-1],f(i));        //输出e数列的相邻两项之差和f(i)的值，看看是否吻合得比较好
    
47.         }
    
48.         puts("");
    
49.         for(i=19;i<999999;i++)
    
50.                 e[i]=e[i-1]+f(i);        //根据f(i)的值延长e数列
    
51.         for(i=19;i<999999;i++)
    
52.                 d[i]=d[i-1]+e[i];        //根据e数列的值延长d数列
    
53.         for(i=19;i<999999;i++)
    
54.                 c[i]=c[i-1]-exp(-log(d[i])*10/4);        //根据d数列的值延长c数列
    
55.         for(i=19;i<999999;i++)
    
56.                 b[i]=b[i-1]+c[i];        //根据c数列的值延长b数列
    
57.         for(i=19;i<999999;i++)
    
58.                 a[i]=a[i-1]+exp(-log(b[i])*11/4);        //根据b数列的值延长a数列
    
59. 
    
60.         for(i=0;i<999999;i+=(i>19?i/2:1))
    
61.                 printf("%6d: %.9lf\n",i,a[i]);        //输出a数列
    
62.         return 0;
    
63. }

复制代码

运行结果如下：

1. 6 1.#QNAN00000000000 0.2199037834745008
   
2. 7 1.#QNAN00000000000 0.7731276358192092
   
3. 8 1.#QNAN00000000000 -1.5104089226742774
   
4. 9 1.#QNAN00000000000 -0.7580833345696476
   
5. 10 -0.3713578484461415 -1.4756140029866442
   
6. 11 0.5864595799163581 0.7922522734689024
   
7. 12 0.1712273296721794 0.2221921798644612
   
8. 13 0.1107856277919126 0.1106504524996588
   
9. 14 0.0669381691118112 0.0672368126045807
   
10. 15 0.0456397026485718 0.0454408775614979
    
11. 16 0.0328465962300193 0.0328526923554737
    
12. 17 0.0248567106136584 0.0248944042293199
    
13. 18 0.0195452906191100 0.0195316657192975
    
14. 
    
15.      0: 0.000000000
    
16.      1: 0.500000000
    
17.      2: 0.541196100
    
18.      3: 0.559296316
    
19.      4: 0.569724134
    
20.      5: 0.575810073
    
21.      6: 0.579702757
    
22.      7: 0.582351295
    
23.      8: 0.584241466
    
24.      9: 0.585641557
    
25.     10: 0.586710034
    
26.     11: 0.587545601
    
27.     12: 0.588212471
    
28.     13: 0.588753954
    
29.     14: 0.589200171
    
30.     15: 0.589572625
    
31.     16: 0.589887014
    
32.     17: 0.590155030
    
33.     18: 0.590385533
    
34.     19: 0.590585342
    
35.     20: 0.590759776
    
36.     30: 0.591733134
    
37.     45: 0.592235286
    
38.     67: 0.592487243
    
39.    100: 0.592616157
    
40.    150: 0.592681661
    
41.    225: 0.592714218
    
42.    337: 0.592730303
    
43.    505: 0.592738279
    
44.    757: 0.592742224
    
45.   1135: 0.592744172
    
46.   1702: 0.592745132
    
47.   2553: 0.592745605
    
48.   3829: 0.592745838
    
49.   5743: 0.592745952
    
50.   8614: 0.592746009
    
51. 12921: 0.592746037
    
52. 19381: 0.592746050
    
53. 29071: 0.592746057
    
54. 43606: 0.592746060
    
55. 65409: 0.592746062
    
56. 98113: 0.592746063
    
57. 147169: 0.592746063
    
58. 220753: 0.592746063
    
59. 331129: 0.592746063
    
60. 496693: 0.592746063
    
61. 745039: 0.592746063

复制代码

我可以看到，$e$数列的相邻两项之差从$i=13$开始与$f(i)$的值吻合得非常好。

根据$f(i)$的值反推$A$数列，得到$A$数列的极限：$0.592746063$。

不知道这个方法是否正确，也不知道准确度有多高。

我没有时间阅读大量的相关文献。

如果谁知道正规一点的方法，请回帖告知。

如果能根据$1#$的数据直接实现一遍就更好了。