数学研发论坛

 找回密码
 欢迎注册
12
返回列表 发新帖
楼主: KeyTo9_Fans

[原创] KeyTo9无限升级的概率

[复制链接]
发表于 2018-11-16 10:45:15 | 显示全部楼层
本帖最后由 lsr314 于 2018-11-16 12:54 编辑

提供一个思路,结论很可能是:KeyTo9可以无限升级的概率是$0$.
考虑经过$n$次升级以后,KeyTo9当前的力量值的期望$E_n$,有递推式$E_0=2,E_(n+1)≈E_n+int_1^(E_n)x*1/x^2dx=E_n+lnE_n.$
近似地有,$E_n≈nlnn.$下一次打得过怪物的概率大约是$1-1/E_n$,于是能无限升级的概率大约是$q=\prod_2^∞(1-1/(nlnn))$
由于和式$\sum_(n=2)^∞1/(nlnn)$是发散的,所以$q=0$.也就是说,KeyTo9可以无限升级的概率是$0$.
$E_n$的递推式不知是否严谨,但是大方向(在渐进的意义上)是没错的,数值验证的结果和渐进式$nlnn$基本一致。
虽然这个结果不够严谨,但是想得到KeyTo9可以无限升级的结论基本上不可能。

评分

参与人数 1威望 +5 金币 +5 贡献 +5 经验 +5 鲜花 +5 收起 理由
KeyTo9_Fans + 5 + 5 + 5 + 5 + 5 我觉得你的猜想是对的,顶你~

查看全部评分

毋因群疑而阻独见  毋任己意而废人言
毋私小惠而伤大体  毋借公论以快私情
发表于 2018-11-24 12:16:14 | 显示全部楼层
这道题目可以试着用三次样条曲线逼近来求解,
设\(\widehat{f_n}(x)\)根据函数取值被均分为\(N\)份,其中又\(\widehat{f_n}(x_{n,h})=\frac h N, 0\le h\le N-1, x_{n,0}=1, t_{n,h}=\widehat{f_n}'(x_{n,h})\)
由于对于每个分段\(x_{n,h}\le x\le x_{n,h+1}\),我们已经知道两个端点函数和其一阶导数的取值,可以唯一确定一个三次函数\(\widehat{f_n}(x)=a_{n,h}+b_{n,h}x+c_{n,h}x^2+d_{n,h}x^3, x_{n,h}\le x\le x_{n,h+1}\),其中唯一问题在于最后一段区间\((x_{n,N-1},\infty)\),我们可以假设这段区间上函数取值形如\(1-\frac1{u_n+v_n x}\),利用函数在\(x_{n,N-1}\)处的取值和一阶导数取值可以唯一确定参数\(u_n,v_n\)
然后利用积分定义容易计算出\(\widehat{f_{n+1}}(x_{n,h})\),由此可以确定每个\(x_{n+1,h}\)所落的区间,由于每个区间里是一个三次函数,解超越方程\(\widehat{f_{n+1}}(x_{n+1,h})=\frac h N\)可以求得\(x_{n+1,h}\)。
下面我们还需要计算\(\widehat{f_{n+1}}'(x_{n+1,h})\),由于\(\widehat{f_{n+1}}(x)=\int_1^x \frac{\widehat{f_n}(x+t)}{t^2}dt\),两边求导得到\(\widehat{f_{n+1}}’(x)=\frac{\widehat{f_n}(2x)}{x^2}+\int_1^x \frac{\widehat{f_n}'(x+t)}{t^2}dt\),由此就可以计算出\(\widehat{f_{n+1}}'(x_{n+1,h})\)
反复迭代上面过程,直到$(x_{n+1,h})$几乎不发生变化,就得到收敛的结果。如果迭代一直无法收敛,说明无解,这时对于给定的$h>0$有,$\lim_{n->\infty} x_{n,h}=\infty$

这个算法中,计算\(a_{n,h}, b_{n,h}, c_{n,h}, d_{n,h}\)需要解一个四元一次方程组,确定\(u_n,v_n\)更简单,解二元一次方程组。
其中解方程\(\widehat{f_{n+1}}(x_{n+1,h})=\frac h N\)是一个超越方程,由于单调,二分法即可,但是这部分计算量有点大
而计算牵涉到的各个定积分,只有最后一个无穷大的区间比较麻烦,我们需要事先推导公式
\(\int \frac{dx}{x^2(u+vx)}=\frac{u+vx\ln(x)-vx\ln(u+vx)}{u^2x}\)和\(\int \frac{dx}{x^2(u+vx)^2}=-\frac{\frac{uv}{u+vx}+\frac u x-2v\ln(u+vx)+2v\ln(x)}{u^3}\)
毋因群疑而阻独见  毋任己意而废人言
毋私小惠而伤大体  毋借公论以快私情
 楼主| 发表于 2018-12-16 14:31:37 | 显示全部楼层
我用C++写了 随机抽样 和 等间距抽样 程序,各跑了$1$天,结果如下:

k29.png

其中标红的部分表示这些数字与准确值不符。

#####

根据以上结果,我的结论是:

—————————————————————————————————
在计算量相同的前提下,等间距抽样 比 随机抽样 的计算结果更准确。
—————————————————————————————————

因此我接下来将会长时间运行等间距抽样程序,计算更大的$n$的近似解。

(之前已经运行了一段时间,但是很不幸实验室停电,我的程序又没有断点续跑功能,所以只好从头开始运行)

请大家静候佳音~

#####

wayne更新了他的计算结果,这是更新之后的表格:

k29.png

根据以上结果,我的结论是:

————————————————————————
在计算量相同的前提下,wayne的计算结果更准确。
————————————————————————

不知道wayne用的是什么算法呢?

精度如此之高,很想学习一下呀~

我的初步猜测是:

wayne先求出准确值的表达式,然后以浮点运算的精度对该表达式进行求值。

点评

恩恩,是的,我的是积分的数值计算  发表于 2018-12-17 17:18
你应该是模拟结果,wayne是公式计算,自然精度要更高  发表于 2018-12-17 10:40
我已经补充到了n=10了  发表于 2018-12-16 20:40
好吧,其实我那个是 浮点数运算,特地 把后面几位也给加上了...  发表于 2018-12-16 16:44
毋因群疑而阻独见  毋任己意而废人言
毋私小惠而伤大体  毋借公论以快私情
发表于 2018-12-16 20:33:26 | 显示全部楼层
KeyTo9_Fans 发表于 2018-12-16 14:31
我用C++写了 随机抽样 和 等间距抽样 程序,各跑了$1$天,结果如下:


听说有个叫Antithetic variable的方法
其实大家都知道等间距抽样是好的
但没人知道等间距抽样产生的误差究竟有多大
大家都知道随机不好,
但是大家可以通过随机数据的方差来估计我们的估计误差

Antithetic variable的想法是把这两个东西结合,一方面借用等间距抽样的精度,一方面加入随机抽样的随机性

做法大约是,对$X~F^{-1}(u_1,u_2,u_3,...)$,生成一个对偶变量$X'~F^{-1}(1-u_1,1-u_2,1-u_3,...)$
理论上,如果$X$跟$X'$的相关系数小于0,这样是可以减小误差的
……
具体实现……我只做过最基本的练习题
仅供参考
毋因群疑而阻独见  毋任己意而废人言
毋私小惠而伤大体  毋借公论以快私情
 楼主| 发表于 2019-1-23 00:46:17 | 显示全部楼层
运行时间够久了,见好就收~

我们先来看看随机抽样的结果(然后再看等间距抽样的结果):

$K29$打$65$只怪$2^34$次,求得存活概率如下:
  1. #include<cmath>
  2. #include<cstdio>

  3. //K29打65只怪2^34次,求得存活概率如下:

  4. double a[66]={
  5. 1.0000000000000000,//打0只怪活下来的概率
  6. 0.5000000000000000,//打1只怪活下来的概率
  7. 0.3513662144559050,//打2只怪活下来的概率
  8. 0.2815932136360760,//打3只怪活下来的概率
  9. 0.2411939870610670,//打4只怪活下来的概率
  10. 0.2147788174076160,//打5只怪活下来的概率
  11. 0.1960844954887230,//打6只怪活下来的概率
  12. 0.1821000514218010,//打7只怪活下来的概率
  13. 0.1712025004164640,//打8只怪活下来的概率
  14. 0.1624406088519320,//打9只怪活下来的概率
  15. 0.1552199392076540,//... ...
  16. 0.1491497625889210,//依次类推
  17. 0.1439625207812350,
  18. 0.1394686720757390,
  19. 0.1355300925893690,
  20. 0.1320436452922420,
  21. 0.1289307025903360,
  22. 0.1261302243508660,
  23. 0.1235940617072260,
  24. 0.1212836967574740,
  25. 0.1191679256057280,
  26. 0.1172211841158430,
  27. 0.1154223169766410,
  28. 0.1137536521266190,
  29. 0.1122003071339890,
  30. 0.1107496512486020,
  31. 0.1093908885908010,
  32. 0.1081147336432270,
  33. 0.1069131496347130,
  34. 0.1057791462666320,
  35. 0.1047066098055320,
  36. 0.1036901669383610,
  37. 0.1027250761863060,
  38. 0.1018071345305470,
  39. 0.1009326024326260,
  40. 0.1000981399239770,
  41. 0.0993007552925089,
  42. 0.0985377579887405,
  43. 0.0978067226882315,
  44. 0.0971054555833467,
  45. 0.0964319675118892,
  46. 0.0957844501656179,
  47. 0.0951612551987818,
  48. 0.0945608768872055,
  49. 0.0939819361677082,
  50. 0.0934231677708489,
  51. 0.0928834082812828,
  52. 0.0923615863941826,
  53. 0.0918567135572522,
  54. 0.0913678756458316,
  55. 0.0908942256862503,
  56. 0.0904349785084306,
  57. 0.0899894045116523,
  58. 0.0895568245676279,
  59. 0.0891366064208952,
  60. 0.0887281593404700,
  61. 0.0883309318481240,
  62. 0.0879444083041124,
  63. 0.0875681055585488,
  64. 0.0872015702317939,
  65. 0.0868443768406531,
  66. 0.0864961255573120,
  67. 0.0861564401382168,
  68. 0.0858249661582232,
  69. 0.0855013695008716,
  70. 0.0851853349845766//打65只怪活下来的概率
  71. },b[66];

  72. int main()
  73. {
  74.         //根据前65只怪的存活概率,用如下方法拟合数据:
  75.         for(int i=0;i<66;i++)
  76.                 printf("%lf\n",exp(5/a[i]/13));
  77.         return 0;
  78. }
  79. /*
  80. 拟合结果如下:

  81. 1.469049
  82. 2.158106
  83. 2.988072
  84. 3.919071
  85. 4.926510
  86. 5.993952
  87. 7.109826
  88. 8.265665
  89. 9.455082
  90. 10.673129
  91. 11.915899
  92. 13.180249
  93. 14.463605
  94. 15.763842
  95. 17.079171
  96. 18.408082
  97. 19.749281
  98. 21.101655
  99. 22.464235
  100. 23.836174
  101. 25.216728
  102. 26.605239
  103. 28.001121
  104. 29.403849
  105. 30.812955
  106. 32.228014
  107. 33.648644
  108. 35.074497
  109. 36.505258
  110. 37.940638
  111. 39.380370
  112. 40.824214
  113. 42.271945
  114. 43.723356
  115. 45.178258
  116. 46.636474
  117. 48.097839
  118. 49.562202
  119. 51.029420
  120. 52.499361
  121. 53.971899
  122. 55.446918
  123. 56.924310
  124. 58.403970
  125. 59.885803
  126. 61.369719
  127. 62.855633
  128. 64.343464
  129. 65.833135
  130. 67.324574
  131. 68.817712
  132. 70.312484
  133. 71.808830
  134. 73.306690
  135. 74.806009
  136. 76.306737
  137. 77.808821
  138. 79.312215
  139. 80.816871
  140. 82.322747
  141. 83.829802
  142. 85.337997
  143. 86.847291
  144. 88.357651
  145. 89.869040
  146. 91.381425

  147. --------------------------------
  148. Process exited after 0.4522 seconds with return value 0
  149. 请按任意键继续. . .
  150. */
复制代码

也就是说,$K29$打了$i$只怪之后,还活着的概率记为$a(i)$,

那么$e^{5/{13a(i)}}$是一个公差约为$1.5~1.6$的等差数列。

#####

我们还可以继续“玩玩”这个“等差数列”,玩法如下。

首先相邻两项作差,得到具体的“公差”,如下所示:
  1. 0.689056
  2. 0.829966
  3. 0.930999
  4. 1.007440
  5. 1.067442
  6. 1.115874
  7. 1.155839
  8. 1.189417
  9. 1.218047
  10. 1.242770
  11. 1.264349
  12. 1.283357
  13. 1.300237
  14. 1.315329
  15. 1.328911
  16. 1.341199
  17. 1.352373
  18. 1.362580
  19. 1.371939
  20. 1.380554
  21. 1.388511
  22. 1.395881
  23. 1.402729
  24. 1.409106
  25. 1.415059
  26. 1.420630
  27. 1.425853
  28. 1.430761
  29. 1.435380
  30. 1.439733
  31. 1.443844
  32. 1.447731
  33. 1.451411
  34. 1.454902
  35. 1.458216
  36. 1.461365
  37. 1.464363
  38. 1.467218
  39. 1.469940
  40. 1.472538
  41. 1.475019
  42. 1.477391
  43. 1.479660
  44. 1.481833
  45. 1.483916
  46. 1.485914
  47. 1.487831
  48. 1.489671
  49. 1.491438
  50. 1.493138
  51. 1.494773
  52. 1.496345
  53. 1.497861
  54. 1.499319
  55. 1.500727
  56. 1.502085
  57. 1.503393
  58. 1.504656
  59. 1.505876
  60. 1.507055
  61. 1.508194
  62. 1.509295
  63. 1.510359
  64. 1.511389
  65. 1.512385
复制代码

所以最终的“公差”确实是$1.5~1.6$之间。

然后再相邻两项作差,得到“零”数列:
  1. 0.140910
  2. 0.101033
  3. 0.076440
  4. 0.060002
  5. 0.048432
  6. 0.039965
  7. 0.033577
  8. 0.028630
  9. 0.024723
  10. 0.021579
  11. 0.019007
  12. 0.016880
  13. 0.015093
  14. 0.013581
  15. 0.012289
  16. 0.011174
  17. 0.010206
  18. 0.009360
  19. 0.008615
  20. 0.007957
  21. 0.007370
  22. 0.006847
  23. 0.006377
  24. 0.005953
  25. 0.005571
  26. 0.005223
  27. 0.004908
  28. 0.004618
  29. 0.004353
  30. 0.004111
  31. 0.003887
  32. 0.003681
  33. 0.003490
  34. 0.003314
  35. 0.003149
  36. 0.002998
  37. 0.002855
  38. 0.002722
  39. 0.002598
  40. 0.002481
  41. 0.002372
  42. 0.002269
  43. 0.002173
  44. 0.002083
  45. 0.001998
  46. 0.001917
  47. 0.001840
  48. 0.001767
  49. 0.001700
  50. 0.001634
  51. 0.001573
  52. 0.001515
  53. 0.001459
  54. 0.001408
  55. 0.001358
  56. 0.001309
  57. 0.001263
  58. 0.001220
  59. 0.001179
  60. 0.001139
  61. 0.001101
  62. 0.001065
  63. 0.001030
  64. 0.000996
复制代码

但这个数列只是趋于零而已,不是真正的“零”数列,

因此我们可以对这个数列的每一项求个倒数,结果如下:
  1. 7.0967
  2. 9.8978
  3. 13.0821
  4. 16.6660
  5. 20.6475
  6. 25.0216
  7. 29.7821
  8. 34.9279
  9. 40.4478
  10. 46.3406
  11. 52.6111
  12. 59.2425
  13. 66.2571
  14. 73.6308
  15. 81.3754
  16. 89.4931
  17. 97.9794
  18. 106.8422
  19. 116.0739
  20. 125.6790
  21. 135.6857
  22. 146.0396
  23. 156.8104
  24. 167.9741
  25. 179.5053
  26. 191.4649
  27. 203.7347
  28. 216.5268
  29. 229.7178
  30. 243.2414
  31. 257.2820
  32. 271.6839
  33. 286.5231
  34. 301.7067
  35. 317.5212
  36. 333.5847
  37. 350.2832
  38. 367.3291
  39. 384.9104
  40. 403.0506
  41. 421.6116
  42. 440.7406
  43. 460.1617
  44. 480.1155
  45. 500.4837
  46. 521.6662
  47. 543.5428
  48. 565.8467
  49. 588.2837
  50. 611.8185
  51. 635.7909
  52. 659.9431
  53. 685.5477
  54. 710.3810
  55. 736.5950
  56. 764.0615
  57. 791.8608
  58. 819.5495
  59. 848.3488
  60. 878.1051
  61. 908.4435
  62. 939.3187
  63. 971.1089
  64. 1004.3377
复制代码

未完待续……

#####

对不起,我的拟合方法有误,最终没能成功拟合这批数据

等我找到bug以后,再重新拟合一次,请大家静候佳音~
毋因群疑而阻独见  毋任己意而废人言
毋私小惠而伤大体  毋借公论以快私情
 楼主| 发表于 2019-1-23 05:15:51 | 显示全部楼层
虽然拟合失败,但是我敢肯定,$11#$($11$楼) lsr314 的猜想是对的!

因为根据楼上($15$楼)的数据拟合表达式,

如果$e^{x/{a(i)}}$(Fans硬说$x$是$5/13$,其实不是,是Fans猜错了)真的是一个递增的“等差”数列的话,

那么当$i->\infty$时,我们有$e^{x/{a(i)}}=ki+l+o(1)$(常数$k>0$,常数$l=?$待定,$o(1)$是无穷小量),

等式两边取对数,也就是$x/{a(i)}=ln(ki+l+o(1))$,

等式两边乘上$a(i)$,也就是$x=a(i)ln(ki+l+o(1))$,

注意:我们现在要的是$a(i)$,不是$x$,因此上式还要重新写一下(等式两边除下$ln(ki+l+o(1))$),最终写成:

$x/{ln(ki+l+o(1))}=a(i)$

所以当$i->\infty$时,把$\infty$代入上式,得到$a(i)$的极限值是$x/{ln(k\infty+l+o(1))}=0$。

所以 lsr314 猜想正确!加$5$分(威望$+5$,金币$+5$,贡献$+5$,经验$+5$,鲜花$+5$)~

#####

我这还有更多的数据证实这一猜想:

$1$、$K29$打$2^20$只怪$2^22$次的结果如下:

$(1)$、$a(1024)\approx 0.05234$,$1024$就是$2^10$

$(2)$、$a(1048576)\approx 0.02771$,$1048576$就是$2^20$

$2$、$K29$打$2^31$只怪($2147483648$只怪)$27647$次的结果如下:
  1. 27647        //K29一共玩了27647局打怪游戏
  2. 0 522        //有522局没死,存活率为522/27647=0.01888...
  3. 1 13787        //有13787局被第1只怪打死了,死亡率为13787/27647=0.49867978...
  4. 2 4026        //有4026局被第2只怪打死了,死亡率为4026/27647=0.145621586...
  5. 3 1982        //……
  6. 4 1095        //依次类推~
  7. 5 772
  8. 6 504
  9. 7 405
  10. 8 323
  11. 9 231
  12. 10 204
  13. 11 195
  14. 12 151
  15. 13 124
  16. 14 142
  17. 15 92
  18. 16 84
  19. 17 61
  20. 18 74
  21. 19 59
  22. 20 56
  23. 21 51
  24. 22 44
  25. 23 46
  26. 24 37
  27. 25 32
  28. 26 44
  29. 27 34
  30. 28 40
  31. 29 30
  32. 30 24
  33. 31 37
  34. 32 23
  35. (中间省略1331行……)
  36. 532168159 1
  37. 561727309 1
  38. 621241415 1
  39. 674399774 1
  40. 678850449 1
  41. 691751747 1
  42. 705548945 1
  43. 755139105 1
  44. 803611478 1
  45. 818034077 1
  46. 826452865 1
  47. 846223733 1
  48. 927544180 1
  49. 1020773376 1
  50. 1117344357 1
  51. 1186318796 1
  52. 1234066443 1
  53. 1276775823 1
  54. 1298175312 1
  55. 1305349955 1
  56. 1308995527 1
  57. 1345644892 1
  58. 1368593503 1
  59. 1437321579 1
  60. 1491328979 1
  61. 1552309585 1
  62. 1608395272 1
  63. 1624049067 1
  64. 1694713319 1
  65. 1937987860 1
  66. 2055735143 1        //运气最差的1次死在第2055735143个怪上
复制代码


想知道上述代码的中间部分是什么样子的吗?

那就下载这个附件看看完整的版本吧~

k29_2.txt (11.89 KB, 下载次数: 0)
毋因群疑而阻独见  毋任己意而废人言
毋私小惠而伤大体  毋借公论以快私情
 楼主| 发表于 2019-1-23 07:14:59 | 显示全部楼层
上天给了Fans一次猜$x$的机会,

但是Fans没有珍惜,直到剧情编不下去了,才后悔不已。

如果上天再给Fans一次机会,

那么Fans会毫不犹豫地把憋了很久的心里话大声地说出来:$x=2/5=0.4$!!!

上天让Fans为自己说的话负责到底,

Fans说:不行啊,我先负责$1$万年再说吧~

#####

玩笑开到这,已经够了。我们推倒重来吧。
  1. #include<cmath>
  2. #include<cstdio>

  3. //K29打65只怪2^34次,求得存活概率如下:

  4. double a[66]={
  5. 1.0000000000000000,//打0只怪活下来的概率
  6. 0.5000000000000000,//打1只怪活下来的概率
  7. 0.3513662144559050,//打2只怪活下来的概率
  8. 0.2815932136360760,//打3只怪活下来的概率
  9. 0.2411939870610670,//打4只怪活下来的概率
  10. 0.2147788174076160,//打5只怪活下来的概率
  11. 0.1960844954887230,//打6只怪活下来的概率
  12. 0.1821000514218010,//打7只怪活下来的概率
  13. 0.1712025004164640,//打8只怪活下来的概率
  14. 0.1624406088519320,//打9只怪活下来的概率
  15. 0.1552199392076540,//... ...
  16. 0.1491497625889210,//依次类推
  17. 0.1439625207812350,
  18. 0.1394686720757390,
  19. 0.1355300925893690,
  20. 0.1320436452922420,
  21. 0.1289307025903360,
  22. 0.1261302243508660,
  23. 0.1235940617072260,
  24. 0.1212836967574740,
  25. 0.1191679256057280,
  26. 0.1172211841158430,
  27. 0.1154223169766410,
  28. 0.1137536521266190,
  29. 0.1122003071339890,
  30. 0.1107496512486020,
  31. 0.1093908885908010,
  32. 0.1081147336432270,
  33. 0.1069131496347130,
  34. 0.1057791462666320,
  35. 0.1047066098055320,
  36. 0.1036901669383610,
  37. 0.1027250761863060,
  38. 0.1018071345305470,
  39. 0.1009326024326260,
  40. 0.1000981399239770,
  41. 0.0993007552925089,
  42. 0.0985377579887405,
  43. 0.0978067226882315,
  44. 0.0971054555833467,
  45. 0.0964319675118892,
  46. 0.0957844501656179,
  47. 0.0951612551987818,
  48. 0.0945608768872055,
  49. 0.0939819361677082,
  50. 0.0934231677708489,
  51. 0.0928834082812828,
  52. 0.0923615863941826,
  53. 0.0918567135572522,
  54. 0.0913678756458316,
  55. 0.0908942256862503,
  56. 0.0904349785084306,
  57. 0.0899894045116523,
  58. 0.0895568245676279,
  59. 0.0891366064208952,
  60. 0.0887281593404700,
  61. 0.0883309318481240,
  62. 0.0879444083041124,
  63. 0.0875681055585488,
  64. 0.0872015702317939,
  65. 0.0868443768406531,
  66. 0.0864961255573120,
  67. 0.0861564401382168,
  68. 0.0858249661582232,
  69. 0.0855013695008716,
  70. 0.0851853349845766//打65只怪活下来的概率
  71. },b[66];

  72. int main()
  73. {
  74.         //根据前65只怪的存活概率,用如下方法拟合数据:
  75.         for(int i=0;i<66;i++)
  76.                 printf("%lf\n",exp(2/a[i]/5));
  77.         return 0;
  78. }
  79. /*
  80. 拟合结果如下:

  81. 1.491825
  82. 2.225541
  83. 3.121811
  84. 4.139143
  85. 5.250987
  86. 6.439050
  87. 7.690124
  88. 8.994333
  89. 10.344081
  90. 11.733388
  91. 13.157455
  92. 14.612366
  93. 16.094876
  94. 17.602265
  95. 19.132225
  96. 20.682779
  97. 22.252220
  98. 23.839063
  99. 25.442002
  100. 27.059889
  101. 28.691700
  102. 30.336527
  103. 31.993550
  104. 33.662034
  105. 35.341313
  106. 37.030782
  107. 38.729891
  108. 40.438134
  109. 42.155053
  110. 43.880221
  111. 45.613247
  112. 47.353769
  113. 49.101450
  114. 50.855980
  115. 52.617070
  116. 54.384449
  117. 56.157865
  118. 57.937082
  119. 59.721879
  120. 61.512046
  121. 63.307390
  122. 65.107723
  123. 66.912874
  124. 68.722676
  125. 70.536975
  126. 72.355625
  127. 74.178488
  128. 76.005430
  129. 77.836325
  130. 79.671053
  131. 81.509501
  132. 83.351561
  133. 85.197129
  134. 87.046108
  135. 88.898401
  136. 90.753920
  137. 92.612581
  138. 94.474299
  139. 96.338995
  140. 98.206594
  141. 100.077024
  142. 101.950214
  143. 103.826097
  144. 105.704610
  145. 107.585689
  146. 109.469275

  147. --------------------------------
  148. Process exited after 0.6761 seconds with return value 0
  149. 请按任意键继续. . .
  150. */
复制代码

需要注意的是,上述代码从第$79$行开始,做了一些改动(具体什么改动?其实就是开头那段玩笑,把$5/13$改成$2/5$了~)。

现在我要为自己说的话负责到底:

上述代码表明,$e^{2/{5a(i)}}$“像”一个等差数列。

怎么像呢?那就准确地说:$e^{2/{5a(i)}}$是一个等差数列与一个无穷小量的和。

我们首先差分一下,得到等差数列的公差与一个无穷小量的和:
  1. 0.733716
  2. 0.896270
  3. 1.017332
  4. 1.111844
  5. 1.188063
  6. 1.251074
  7. 1.304208
  8. 1.349749
  9. 1.389307
  10. 1.424067
  11. 1.454911
  12. 1.482510
  13. 1.507389
  14. 1.529959
  15. 1.550554
  16. 1.569442
  17. 1.586842
  18. 1.602940
  19. 1.617886
  20. 1.631812
  21. 1.644827
  22. 1.657023
  23. 1.668484
  24. 1.679279
  25. 1.689469
  26. 1.699108
  27. 1.708243
  28. 1.716919
  29. 1.725168
  30. 1.733025
  31. 1.740522
  32. 1.747682
  33. 1.754530
  34. 1.761089
  35. 1.767379
  36. 1.773416
  37. 1.779217
  38. 1.784796
  39. 1.790168
  40. 1.795343
  41. 1.800334
  42. 1.805150
  43. 1.809802
  44. 1.814299
  45. 1.818650
  46. 1.822862
  47. 1.826942
  48. 1.830895
  49. 1.834728
  50. 1.838449
  51. 1.842060
  52. 1.845568
  53. 1.848978
  54. 1.852293
  55. 1.855520
  56. 1.858661
  57. 1.861718
  58. 1.864696
  59. 1.867599
  60. 1.870430
  61. 1.873190
  62. 1.875883
  63. 1.878513
  64. 1.881080
  65. 1.883586
复制代码

再差分一次,就没有公差了,就只剩下一个无穷小量了,结果如下:
  1. 0.162554
  2. 0.121061
  3. 0.094513
  4. 0.076219
  5. 0.063011
  6. 0.053135
  7. 0.045540
  8. 0.039558
  9. 0.034760
  10. 0.030844
  11. 0.027598
  12. 0.024880
  13. 0.022570
  14. 0.020595
  15. 0.018888
  16. 0.017401
  17. 0.016097
  18. 0.014947
  19. 0.013926
  20. 0.013015
  21. 0.012196
  22. 0.011461
  23. 0.010795
  24. 0.010190
  25. 0.009639
  26. 0.009135
  27. 0.008675
  28. 0.008249
  29. 0.007857
  30. 0.007496
  31. 0.007160
  32. 0.006849
  33. 0.006559
  34. 0.006290
  35. 0.006036
  36. 0.005801
  37. 0.005579
  38. 0.005371
  39. 0.005176
  40. 0.004991
  41. 0.004817
  42. 0.004652
  43. 0.004497
  44. 0.004351
  45. 0.004212
  46. 0.004080
  47. 0.003953
  48. 0.003833
  49. 0.003721
  50. 0.003611
  51. 0.003508
  52. 0.003410
  53. 0.003315
  54. 0.003227
  55. 0.003141
  56. 0.003057
  57. 0.002978
  58. 0.002903
  59. 0.002831
  60. 0.002761
  61. 0.002693
  62. 0.002629
  63. 0.002567
  64. 0.002506
复制代码

经过仔细观察,Fans认为:这个无穷小量很可能是某个$3$次函数的倒数,

所以接下来把这个数列倒一下,变成一个$3$次的函数,结果如下:
  1. 6.1518
  2. 8.2603
  3. 10.5806
  4. 13.1202
  5. 15.8703
  6. 18.8201
  7. 21.9587
  8. 25.2791
  9. 28.7686
  10. 32.4210
  11. 36.2340
  12. 40.1933
  13. 44.3065
  14. 48.5563
  15. 52.9448
  16. 57.4688
  17. 62.1223
  18. 66.9052
  19. 71.8103
  20. 76.8361
  21. 81.9914
  22. 87.2492
  23. 92.6360
  24. 98.1379
  25. 103.7414
  26. 109.4678
  27. 115.2677
  28. 121.2200
  29. 127.2734
  30. 133.4011
  31. 139.6673
  32. 146.0128
  33. 152.4617
  34. 158.9797
  35. 165.6602
  36. 172.3730
  37. 179.2416
  38. 186.1699
  39. 193.2148
  40. 200.3794
  41. 207.6184
  42. 214.9729
  43. 222.3598
  44. 229.8469
  45. 237.3982
  46. 245.1207
  47. 252.9752
  48. 260.8870
  49. 268.7790
  50. 276.8974
  51. 285.0685
  52. 293.2282
  53. 301.6832
  54. 309.8970
  55. 318.3804
  56. 327.0922
  57. 335.8168
  58. 344.4576
  59. 353.2829
  60. 362.2523
  61. 371.2816
  62. 380.3596
  63. 389.5607
  64. 398.9827
复制代码

上次的剧情就编到这,Fans就编不下去了。

这次Fans把$x$的值改过来了,所以剧情可以继续了~

因为是$3$次函数,所以接下来做个开立方运算,

开了立方之后,这个函数就变成$1$次函数了,结果如下:
  1. 1.832317
  2. 2.021458
  3. 2.195348
  4. 2.358558
  5. 2.513013
  6. 2.659953
  7. 2.800285
  8. 2.934859
  9. 3.064122
  10. 3.188665
  11. 3.309065
  12. 3.425453
  13. 3.538527
  14. 3.648228
  15. 3.754981
  16. 3.859023
  17. 3.960492
  18. 4.059632
  19. 4.156510
  20. 4.251300
  21. 4.344330
  22. 4.435275
  23. 4.524736
  24. 4.612598
  25. 4.698768
  26. 4.783680
  27. 4.866715
  28. 4.949083
  29. 5.030130
  30. 5.109595
  31. 5.188378
  32. 5.265791
  33. 5.342201
  34. 5.417271
  35. 5.492112
  36. 5.565315
  37. 5.638275
  38. 5.710005
  39. 5.781140
  40. 5.851731
  41. 5.921367
  42. 5.990474
  43. 6.058318
  44. 6.125566
  45. 6.191927
  46. 6.258352
  47. 6.324497
  48. 6.389754
  49. 6.453546
  50. 6.517879
  51. 6.581371
  52. 6.643576
  53. 6.706826
  54. 6.767150
  55. 6.828345
  56. 6.890066
  57. 6.950789
  58. 7.009901
  59. 7.069264
  60. 7.128591
  61. 7.187334
  62. 7.245440
  63. 7.303399
  64. 7.361811
复制代码

因为是$1$次函数,所以可以把这个函数看成一个等差数列与一个无穷小量的和。

于是接下来差分一下,看看这个等差数列的公差到底是多少:
  1. 0.189141
  2. 0.173890
  3. 0.163209
  4. 0.154455
  5. 0.146940
  6. 0.140332
  7. 0.134575
  8. 0.129263
  9. 0.124542
  10. 0.120400
  11. 0.116389
  12. 0.113073
  13. 0.109701
  14. 0.106753
  15. 0.104042
  16. 0.101469
  17. 0.099140
  18. 0.096878
  19. 0.094790
  20. 0.093030
  21. 0.090945
  22. 0.089461
  23. 0.087862
  24. 0.086171
  25. 0.084911
  26. 0.083035
  27. 0.082368
  28. 0.081047
  29. 0.079465
  30. 0.078783
  31. 0.077413
  32. 0.076410
  33. 0.075070
  34. 0.074841
  35. 0.073203
  36. 0.072960
  37. 0.071730
  38. 0.071135
  39. 0.070591
  40. 0.069636
  41. 0.069108
  42. 0.067844
  43. 0.067248
  44. 0.066361
  45. 0.066425
  46. 0.066145
  47. 0.065257
  48. 0.063792
  49. 0.064333
  50. 0.063493
  51. 0.062204
  52. 0.063250
  53. 0.060323
  54. 0.061195
  55. 0.061721
  56. 0.060723
  57. 0.059112
  58. 0.059363
  59. 0.059327
  60. 0.058742
  61. 0.058107
  62. 0.057959
  63. 0.058412
复制代码

这样就很清楚了,这个等差数列的公差介于$0.05$到$0.06$之间。

如果再差分一次,那么这个等差数列就连公差都抵消掉了,就只剩下一个无穷小量了。

所以我们再来差分一下,看看这个无穷小量到底是个什么东西:
  1. -0.01525097
  2. -0.01068094
  3. -0.00875411
  4. -0.00751544
  5. -0.00660746
  6. -0.00575766
  7. -0.00531161
  8. -0.00472049
  9. -0.00414279
  10. -0.00401098
  11. -0.00331540
  12. -0.00337213
  13. -0.00294795
  14. -0.00271077
  15. -0.00257343
  16. -0.00232920
  17. -0.00226204
  18. -0.00208770
  19. -0.00176001
  20. -0.00208529
  21. -0.00148385
  22. -0.00159924
  23. -0.00169120
  24. -0.00125916
  25. -0.00187625
  26. -0.00066710
  27. -0.00132092
  28. -0.00158207
  29. -0.00068221
  30. -0.00136978
  31. -0.00100261
  32. -0.00134044
  33. -0.00022892
  34. -0.00163824
  35. -0.00024305
  36. -0.00122928
  37. -0.00059582
  38. -0.00054408
  39. -0.00095459
  40. -0.00052825
  41. -0.00126385
  42. -0.00059620
  43. -0.00088675
  44. 0.00006387
  45. -0.00027943
  46. -0.00088850
  47. -0.00146457
  48. 0.00054019
  49. -0.00084002
  50. -0.00128805
  51. 0.00104600
  52. -0.00292698
  53. 0.00087170
  54. 0.00052620
  55. -0.00099837
  56. -0.00161092
  57. 0.00025092
  58. -0.00003598
  59. -0.00058464
  60. -0.00063570
  61. -0.00014767
  62. 0.00045267
复制代码

这个无穷小量看起来是一个$2$次函数的倒数,

可惜这个函数倒不回来,因为函数值有正有负的,硬倒回来就倒坏了。

我接下来要好好地护着这个函数,不能把它玩坏了……

……怎样才能不被玩坏,又能获得它的近似表达式呢?

——我想到了作图。

那就先把图作出来,看看是啥东西再说:

k29_fun.png

图作出来了,确实是个无穷小量,因为它的极限确实是趋于$0$的,

只是这个函数“抖”得太厉害了。

——为什么会“抖”得这么厉害呢?

因为这是随机取样$2^34$次的计算结果呀~ 有抽样误差在呀~

抽样误差本来是很小很小的,

但是经过一系列变换之后,这个误差越来越大了~

最后大到导致整个【看起来像$2$次函数的倒数】的函数都倒不回去了,无法继续做变换了~

那接下来该怎么办呢?

像这种抖得这么利害的函数,我能想到的唯一办法就是上工具。

有一个叫做【Curve Expert】的神奇工具,你给他一堆散点,他就可以给你一个函数。

(不管你给他的点再散再乱,他都可以给你整个函数出来~)

于是我就把这些【看起来像$2$次函数的倒数的散点】的相反数给他了。

不出所料,他给了我一个函数,说【这个函数是所有函数中拟合得最好的一个函数】:

CurveExpert.png

我看了一下,这个函数确实是【$2$次函数的倒数】。

有了这个函数,我就可以预测$i>65$的函数值,然后反推回去,得到$i>65$时的$a(i)$的值。

#####

接下来,见证奇迹的时刻到了。

我们把反推回去的$a(i)$的值与之前所列的值比较一下,看看是否一致:

$(1)$、$a(2^10)\approx 0.05234$:反推回去的$a(2^10)=0.052336710482$,一致!

$(2)$、$a(2^20)\approx 0.02771$:反推回去的$a(2^20)=0.027378206249$,糟糕,不一致……

$(3)$、$a(2^31)\approx 0.01888$:反推回去的$a(2^31)=0.017989797245$,糟糕,这个也不一致……

拟合还是不成功,还得重来……
毋因群疑而阻独见  毋任己意而废人言
毋私小惠而伤大体  毋借公论以快私情
 楼主| 发表于 2019-1-23 07:26:48 | 显示全部楼层
再占个楼,慢慢编辑……

#####

之所以拟合再次失败,是因为$x$是个变量$x(i)$,不是常量$x$。

只是$x(i)$这个变量变化得太慢了,以至于Fans只看到$x(i)$的一部分,就以为$x$是个常量。

第$1$次拟合,Fans看到的是$x(66)$,所以说$x=5/13$;

要真取了$x=5/13$吧?那结果就只是$a(66)$一致,其它不一致。

第$2$次拟合,Fans看到的是$x(1024)$,所以说$x=2/5$;

要真取了$x=2/5$吧?那结果就只是$a(1024)$一致,其它不一致。

想让$a(1048576)$一致?

得取$x=5/12$~

想让$a(2^31)$一致?

那$x$要取啥连Fans自己都不清楚,更别说其他网友了。

这题做到这,Fans已经精疲力尽了,需要休息一段时间,再回过头来搞$x(i)$这个鬼东西~
毋因群疑而阻独见  毋任己意而废人言
毋私小惠而伤大体  毋借公论以快私情
您需要登录后才可以回帖 登录 | 欢迎注册

本版积分规则

小黑屋|手机版|数学研发网 ( 苏ICP备07505100号 )

GMT+8, 2019-10-23 16:00 , Processed in 0.086501 second(s), 19 queries .

Powered by Discuz! X3.4

© 2001-2017 Comsenz Inc.

快速回复 返回顶部 返回列表