fork download
copy 
  1. # 以牛頓法求 x^2 - 0.5 = 0 的根, x >= 0
  2. # 結果應接近 sqrt(0.5) ~= 0.7071
  3. # 初始值設定在 0-100
  4. # 最多重覆 10 次; 若第 10 次的差值仍不小於 delta 則自我遞迴重新做一次
  5. # 因為 fx 沒有寫死, 這個牛頓法應可以用在其它求根問題上
  6. NTM <-
  7.   function(fx = expression(x ^ 2 - 0.5),
  8.            initial = expression(runif(1, 0, 100)),
  9.            delta = 1e-10,
  10.            iter.max = 10,
  11.            trace = T) {
  12.     iter <- 1
  13.     x <- eval(initial)
  14.     while (iter <= iter.max) {
  15.       fx.val <- eval(fx)
  16.       fx.dx.val <- eval(D(fx, "x"))
  17.       x1 <- x - fx.val / fx.dx.val
  18.       delta.this <- abs(x1 - x)
  19.       if (trace) {
  20.         cat(
  21.           "iter =", iter,
  22.           ", x =", x,
  23.           "next x =", x1,
  24.           ", 差值 =", delta.this,
  25.           ", 差值是否夠小:", delta.this < delta,
  26.           "\n"
  27.         )
  28.       }
  29.  
  30.       if (delta.this >= delta) {
  31.         x <- x1
  32.         iter <- iter + 1
  33.       } else {
  34.         break
  35.       }
  36.     }
  37.  
  38.     if (iter - 1 == iter.max & delta.this >= delta) {
  39.       if (trace) cat("已經做", iter - 1, "次了但差值", delta.this, "仍未小於", delta, "所以自我遞迴重做一次", "\n")
  40.       NTM(fx = fx, initial = initial, delta = delta, iter.max = iter.max, trace = trace)
  41.     } else {
  42.       if (trace) cat("達到標準; 完成\n\n")
  43.       return(x)
  44.     }
  45.   }
  46.  
  47. # 進行 1 次 NTM()
  48. NTM()
  49.  
  50. # 進行 5 次 NTM() 看看
  51. res <- replicate(5, NTM(trace = F))
  52. # 求 5 次 NTM() 的平均
  53. mean(res)
  54.  
  55. # 改成求 x ^ 3 - 27.001 = 0 的根
  56. NTM(fx = expression(x ^ 3 - 27.001))
  57.  
Success #stdin #stdout 0.26s 39444KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
iter = 1 , x = 62.75519 next x = 31.38158 , 差值 = 31.37361 , 差值是否夠小: FALSE 
iter = 2 , x = 31.38158 next x = 15.69876 , 差值 = 15.68282 , 差值是否夠小: FALSE 
iter = 3 , x = 15.69876 next x = 7.865303 , 差值 = 7.833453 , 差值是否夠小: FALSE 
iter = 4 , x = 7.865303 next x = 3.964437 , 差值 = 3.900866 , 差值是否夠小: FALSE 
iter = 5 , x = 3.964437 next x = 2.045279 , 差值 = 1.919158 , 差值是否夠小: FALSE 
iter = 6 , x = 2.045279 next x = 1.144872 , 差值 = 0.9004068 , 差值是否夠小: FALSE 
iter = 7 , x = 1.144872 next x = 0.7908011 , 差值 = 0.3540711 , 差值是否夠小: FALSE 
iter = 8 , x = 0.7908011 next x = 0.7115357 , 差值 = 0.07926541 , 差值是否夠小: FALSE 
iter = 9 , x = 0.7115357 next x = 0.7071206 , 差值 = 0.004415103 , 差值是否夠小: FALSE 
iter = 10 , x = 0.7071206 next x = 0.7071068 , 差值 = 1.378346e-05 , 差值是否夠小: FALSE 
已經做 10 次了但差值 1.378346e-05 仍未小於 1e-10 所以自我遞迴重做一次 
iter = 1 , x = 57.05149 next x = 28.53013 , 差值 = 28.52136 , 差值是否夠小: FALSE 
iter = 2 , x = 28.53013 next x = 14.27383 , 差值 = 14.2563 , 差值是否夠小: FALSE 
iter = 3 , x = 14.27383 next x = 7.154428 , 差值 = 7.119399 , 差值是否夠小: FALSE 
iter = 4 , x = 7.154428 next x = 3.612157 , 差值 = 3.542271 , 差值是否夠小: FALSE 
iter = 5 , x = 3.612157 next x = 1.875289 , 差值 = 1.736868 , 差值是否夠小: FALSE 
iter = 6 , x = 1.875289 next x = 1.070957 , 差值 = 0.804332 , 差值是否夠小: FALSE 
iter = 7 , x = 1.070957 next x = 0.7689147 , 差值 = 0.3020428 , 差值是否夠小: FALSE 
iter = 8 , x = 0.7689147 next x = 0.7095909 , 差值 = 0.05932376 , 差值是否夠小: FALSE 
iter = 9 , x = 0.7095909 next x = 0.7071111 , 差值 = 0.002479815 , 差值是否夠小: FALSE 
iter = 10 , x = 0.7071111 next x = 0.7071068 , 差值 = 4.348315e-06 , 差值是否夠小: FALSE 
已經做 10 次了但差值 4.348315e-06 仍未小於 1e-10 所以自我遞迴重做一次 
iter = 1 , x = 89.10932 next x = 44.55746 , 差值 = 44.55185 , 差值是否夠小: FALSE 
iter = 2 , x = 44.55746 next x = 22.28434 , 差值 = 22.27312 , 差值是否夠小: FALSE 
iter = 3 , x = 22.28434 next x = 11.15339 , 差值 = 11.13095 , 差值是否夠小: FALSE 
iter = 4 , x = 11.15339 next x = 5.59911 , 差值 = 5.55428 , 差值是否夠小: FALSE 
iter = 5 , x = 5.59911 next x = 2.844205 , 差值 = 2.754905 , 差值是否夠小: FALSE 
iter = 6 , x = 2.844205 next x = 1.51 , 差值 = 1.334204 , 差值是否夠小: FALSE 
iter = 7 , x = 1.51 next x = 0.9205631 , 差值 = 0.5894373 , 差值是否夠小: FALSE 
iter = 8 , x = 0.9205631 next x = 0.7318545 , 差值 = 0.1887086 , 差值是否夠小: FALSE 
iter = 9 , x = 0.7318545 next x = 0.7075252 , 差值 = 0.02432925 , 差值是否夠小: FALSE 
iter = 10 , x = 0.7075252 next x = 0.7071069 , 差值 = 0.0004182978 , 差值是否夠小: FALSE 
已經做 10 次了但差值 0.0004182978 仍未小於 1e-10 所以自我遞迴重做一次 
iter = 1 , x = 56.71285 next x = 28.36083 , 差值 = 28.35202 , 差值是否夠小: FALSE 
iter = 2 , x = 28.36083 next x = 14.18923 , 差值 = 14.1716 , 差值是否夠小: FALSE 
iter = 3 , x = 14.18923 next x = 7.112235 , 差值 = 7.076997 , 差值是否夠小: FALSE 
iter = 4 , x = 7.112235 next x = 3.591268 , 差值 = 3.520967 , 差值是否夠小: FALSE 
iter = 5 , x = 3.591268 next x = 1.865247 , 差值 = 1.726021 , 差值是否夠小: FALSE 
iter = 6 , x = 1.865247 next x = 1.066654 , 差值 = 0.7985932 , 差值是否夠小: FALSE 
iter = 7 , x = 1.066654 next x = 0.7677048 , 差值 = 0.2989493 , 差值是否夠小: FALSE 
iter = 8 , x = 0.7677048 next x = 0.7094984 , 差值 = 0.05820641 , 差值是否夠小: FALSE 
iter = 9 , x = 0.7094984 next x = 0.7071108 , 差值 = 0.002387593 , 差值是否夠小: FALSE 
iter = 10 , x = 0.7071108 next x = 0.7071068 , 差值 = 4.03091e-06 , 差值是否夠小: FALSE 
已經做 10 次了但差值 4.03091e-06 仍未小於 1e-10 所以自我遞迴重做一次 
iter = 1 , x = 92.04944 next x = 46.02744 , 差值 = 46.022 , 差值是否夠小: FALSE 
iter = 2 , x = 46.02744 next x = 23.01915 , 差值 = 23.00829 , 差值是否夠小: FALSE 
iter = 3 , x = 23.01915 next x = 11.52044 , 差值 = 11.49871 , 差值是否夠小: FALSE 
iter = 4 , x = 11.52044 next x = 5.781918 , 差值 = 5.738517 , 差值是否夠小: FALSE 
iter = 5 , x = 5.781918 next x = 2.934197 , 差值 = 2.847721 , 差值是否夠小: FALSE 
iter = 6 , x = 2.934197 next x = 1.552301 , 差值 = 1.381896 , 差值是否夠小: FALSE 
iter = 7 , x = 1.552301 next x = 0.9372017 , 差值 = 0.6150992 , 差值是否夠小: FALSE 
iter = 8 , x = 0.9372017 next x = 0.7353524 , 差值 = 0.2018493 , 差值是否夠小: FALSE 
iter = 9 , x = 0.7353524 next x = 0.7076493 , 差值 = 0.02770314 , 差值是否夠小: FALSE 
iter = 10 , x = 0.7076493 next x = 0.707107 , 差值 = 0.0005422628 , 差值是否夠小: FALSE 
已經做 10 次了但差值 0.0005422628 仍未小於 1e-10 所以自我遞迴重做一次 
iter = 1 , x = 38.20986 next x = 19.11147 , 差值 = 19.09839 , 差值是否夠小: FALSE 
iter = 2 , x = 19.11147 next x = 9.568817 , 差值 = 9.542654 , 差值是否夠小: FALSE 
iter = 3 , x = 9.568817 next x = 4.810535 , 差值 = 4.758282 , 差值是否夠小: FALSE 
iter = 4 , x = 4.810535 next x = 2.457237 , 差值 = 2.353298 , 差值是否夠小: FALSE 
iter = 5 , x = 2.457237 next x = 1.330359 , 差值 = 1.126878 , 差值是否夠小: FALSE 
iter = 6 , x = 1.330359 next x = 0.8530986 , 差值 = 0.4772601 , 差值是否夠小: FALSE 
iter = 7 , x = 0.8530986 next x = 0.7195987 , 差值 = 0.1334999 , 差值是否夠小: FALSE 
iter = 8 , x = 0.7195987 next x = 0.7072152 , 差值 = 0.01238345 , 差值是否夠小: FALSE 
iter = 9 , x = 0.7072152 next x = 0.7071068 , 差值 = 0.0001084181 , 差值是否夠小: FALSE 
iter = 10 , x = 0.7071068 next x = 0.7071068 , 差值 = 8.311672e-09 , 差值是否夠小: FALSE 
已經做 10 次了但差值 8.311672e-09 仍未小於 1e-10 所以自我遞迴重做一次 
iter = 1 , x = 88.78674 next x = 44.39618 , 差值 = 44.39055 , 差值是否夠小: FALSE 
iter = 2 , x = 44.39618 next x = 22.20372 , 差值 = 22.19246 , 差值是否夠小: FALSE 
iter = 3 , x = 22.20372 next x = 11.11312 , 差值 = 11.0906 , 差值是否夠小: FALSE 
iter = 4 , x = 11.11312 next x = 5.579056 , 差值 = 5.534065 , 差值是否夠小: FALSE 
iter = 5 , x = 5.579056 next x = 2.834339 , 差值 = 2.744718 , 差值是否夠小: FALSE 
iter = 6 , x = 2.834339 next x = 1.505373 , 差值 = 1.328965 , 差值是否夠小: FALSE 
iter = 7 , x = 1.505373 next x = 0.9187584 , 差值 = 0.5866149 , 差值是否夠小: FALSE 
iter = 8 , x = 0.9187584 next x = 0.7314856 , 差值 = 0.1872729 , 差值是否夠小: FALSE 
iter = 9 , x = 0.7314856 next x = 0.707513 , 差值 = 0.02397253 , 差值是否夠小: FALSE 
iter = 10 , x = 0.707513 next x = 0.7071069 , 差值 = 0.0004061285 , 差值是否夠小: FALSE 
已經做 10 次了但差值 0.0004061285 仍未小於 1e-10 所以自我遞迴重做一次 
iter = 1 , x = 15.56682 next x = 7.799471 , 差值 = 7.767351 , 差值是否夠小: FALSE 
iter = 2 , x = 7.799471 next x = 3.931789 , 差值 = 3.867682 , 差值是否夠小: FALSE 
iter = 3 , x = 3.931789 next x = 2.029479 , 差值 = 1.90231 , 差值是否夠小: FALSE 
iter = 4 , x = 2.029479 next x = 1.137924 , 差值 = 0.891555 , 差值是否夠小: FALSE 
iter = 5 , x = 1.137924 next x = 0.7886602 , 差值 = 0.3492635 , 差值是否夠小: FALSE 
iter = 6 , x = 0.7886602 next x = 0.7113234 , 差值 = 0.07733683 , 差值是否夠小: FALSE 
iter = 7 , x = 0.7113234 next x = 0.7071193 , 差值 = 0.004204126 , 差值是否夠小: FALSE 
iter = 8 , x = 0.7071193 next x = 0.7071068 , 差值 = 1.249766e-05 , 差值是否夠小: FALSE 
iter = 9 , x = 0.7071068 next x = 0.7071068 , 差值 = 1.104441e-10 , 差值是否夠小: FALSE 
iter = 10 , x = 0.7071068 next x = 0.7071068 , 差值 = 1.110223e-16 , 差值是否夠小: TRUE 
達到標準; 完成

[1] 0.7071068
[1] 0.7071068
iter = 1 , x = 61.30324 next x = 40.87122 , 差值 = 20.43202 , 差值是否夠小: FALSE 
iter = 2 , x = 40.87122 next x = 27.25287 , 差值 = 13.61835 , 差值是否夠小: FALSE 
iter = 3 , x = 27.25287 next x = 18.1807 , 差值 = 9.072172 , 差值是否夠小: FALSE 
iter = 4 , x = 18.1807 next x = 12.1477 , 差值 = 6.033004 , 差值是否夠小: FALSE 
iter = 5 , x = 12.1477 next x = 8.159455 , 差值 = 3.98824 , 差值是否夠小: FALSE 
iter = 6 , x = 8.159455 next x = 5.574824 , 差值 = 2.584631 , 差值是否夠小: FALSE 
iter = 7 , x = 5.574824 next x = 4.006148 , 差值 = 1.568676 , 差值是否夠小: FALSE 
iter = 8 , x = 4.006148 next x = 3.231561 , 差值 = 0.774587 , 差值是否夠小: FALSE 
iter = 9 , x = 3.231561 next x = 3.016228 , 差值 = 0.2153326 , 差值是否夠小: FALSE 
iter = 10 , x = 3.016228 next x = 3.000124 , 差值 = 0.01610454 , 差值是否夠小: FALSE 
已經做 10 次了但差值 0.01610454 仍未小於 1e-10 所以自我遞迴重做一次 
iter = 1 , x = 69.51435 next x = 46.34476 , 差值 = 23.16959 , 差值是否夠小: FALSE 
iter = 2 , x = 46.34476 next x = 30.9007 , 差值 = 15.44406 , 差值是否夠小: FALSE 
iter = 3 , x = 30.9007 next x = 20.60989 , 差值 = 10.29081 , 差值是否夠小: FALSE 
iter = 4 , x = 20.60989 next x = 13.76112 , 差值 = 6.848775 , 差值是否夠小: FALSE 
iter = 5 , x = 13.76112 next x = 9.221606 , 差值 = 4.539511 , 差值是否夠小: FALSE 
iter = 6 , x = 9.221606 next x = 6.253576 , 差值 = 2.96803 , 差值是否夠小: FALSE 
iter = 7 , x = 6.253576 next x = 4.399196 , 差值 = 1.85438 , 差值是否夠小: FALSE 
iter = 8 , x = 4.399196 next x = 3.39786 , 差值 = 1.001335 , 差值是否夠小: FALSE 
iter = 9 , x = 3.39786 next x = 3.044797 , 差值 = 0.3530638 , 差值是否夠小: FALSE 
iter = 10 , x = 3.044797 next x = 3.000692 , 差值 = 0.04410486 , 差值是否夠小: FALSE 
已經做 10 次了但差值 0.04410486 仍未小於 1e-10 所以自我遞迴重做一次 
iter = 1 , x = 89.94536 next x = 59.96468 , 差值 = 29.98067 , 差值是否夠小: FALSE 
iter = 2 , x = 59.96468 next x = 39.97896 , 差值 = 19.98572 , 差值是否夠小: FALSE 
iter = 3 , x = 39.97896 next x = 26.65827 , 差值 = 13.32069 , 差值是否夠小: FALSE 
iter = 4 , x = 26.65827 next x = 17.78484 , 差值 = 8.873425 , 差值是否夠小: FALSE 
iter = 5 , x = 17.78484 next x = 11.88502 , 差值 = 5.899827 , 差值是否夠小: FALSE 
iter = 6 , x = 11.88502 next x = 7.987063 , 差值 = 3.897955 , 差值是否夠小: FALSE 
iter = 7 , x = 7.987063 next x = 5.465795 , 差值 = 2.521268 , 差值是否夠小: FALSE 
iter = 8 , x = 5.465795 next x = 3.94513 , 差值 = 1.520664 , 差值是否夠小: FALSE 
iter = 9 , x = 3.94513 next x = 3.208364 , 差值 = 0.7367666 , 差值是否夠小: FALSE 
iter = 10 , x = 3.208364 next x = 3.013271 , 差值 = 0.1950925 , 差值是否夠小: FALSE 
已經做 10 次了但差值 0.1950925 仍未小於 1e-10 所以自我遞迴重做一次 
iter = 1 , x = 50.72896 next x = 33.82281 , 差值 = 16.90616 , 差值是否夠小: FALSE 
iter = 2 , x = 33.82281 next x = 22.55641 , 差值 = 11.2664 , 差值是否夠小: FALSE 
iter = 3 , x = 22.55641 next x = 15.05529 , 差值 = 7.501112 , 差值是否夠小: FALSE 
iter = 4 , x = 15.05529 next x = 10.07657 , 差值 = 4.978723 , 差值是否夠小: FALSE 
iter = 5 , x = 10.07657 next x = 6.806354 , 差值 = 3.270216 , 差值是否夠小: FALSE 
iter = 6 , x = 6.806354 next x = 4.73185 , 差值 = 2.074504 , 差值是否夠小: FALSE 
iter = 7 , x = 4.73185 next x = 3.55654 , 差值 = 1.175311 , 差值是否夠小: FALSE 
iter = 8 , x = 3.55654 next x = 3.082573 , 差值 = 0.4739667 , 差值是否夠小: FALSE 
iter = 9 , x = 3.082573 next x = 3.002227 , 差值 = 0.08034569 , 差值是否夠小: FALSE 
iter = 10 , x = 3.002227 next x = 3.000039 , 差值 = 0.002188577 , 差值是否夠小: FALSE 
已經做 10 次了但差值 0.002188577 仍未小於 1e-10 所以自我遞迴重做一次 
iter = 1 , x = 35.76238 next x = 23.84862 , 差值 = 11.91376 , 差值是否夠小: FALSE 
iter = 2 , x = 23.84862 next x = 15.91491 , 差值 = 7.933717 , 差值是否夠小: FALSE 
iter = 3 , x = 15.91491 next x = 10.64547 , 差值 = 5.269435 , 差值是否夠小: FALSE 
iter = 4 , x = 10.64547 next x = 7.176402 , 差值 = 3.469071 , 差值是否夠小: FALSE 
iter = 5 , x = 7.176402 next x = 4.959029 , 差值 = 2.217373 , 差值是否夠小: FALSE 
iter = 6 , x = 4.959029 next x = 3.672006 , 差值 = 1.287023 , 差值是否夠小: FALSE 
iter = 7 , x = 3.672006 next x = 3.115505 , 差值 = 0.5565012 , 差值是否夠小: FALSE 
iter = 8 , x = 3.115505 next x = 3.004264 , 差值 = 0.1112412 , 差值是否夠小: FALSE 
iter = 9 , x = 3.004264 next x = 3.000043 , 差值 = 0.004220692 , 差值是否夠小: FALSE 
iter = 10 , x = 3.000043 next x = 3.000037 , 差值 = 5.943566e-06 , 差值是否夠小: FALSE 
已經做 10 次了但差值 5.943566e-06 仍未小於 1e-10 所以自我遞迴重做一次 
iter = 1 , x = 41.31581 next x = 27.54915 , 差值 = 13.76666 , 差值是否夠小: FALSE 
iter = 2 , x = 27.54915 next x = 18.37796 , 差值 = 9.17119 , 差值是否夠小: FALSE 
iter = 3 , x = 18.37796 next x = 12.27862 , 差值 = 6.099337 , 差值是否夠小: FALSE 
iter = 4 , x = 12.27862 next x = 8.245444 , 差值 = 4.033175 , 差值是否夠小: FALSE 
iter = 5 , x = 8.245444 next x = 5.629345 , 差值 = 2.616099 , 差值是否夠小: FALSE 
iter = 6 , x = 5.629345 next x = 4.036913 , 差值 = 1.592432 , 差值是否夠小: FALSE 
iter = 7 , x = 4.036913 next x = 3.243556 , 差值 = 0.7933569 , 差值是否夠小: FALSE 
iter = 8 , x = 3.243556 next x = 3.017862 , 差值 = 0.2256935 , 差值是否夠小: FALSE 
iter = 9 , x = 3.017862 next x = 3.000142 , 差值 = 0.01772022 , 差值是否夠小: FALSE 
iter = 10 , x = 3.000142 next x = 3.000037 , 差值 = 0.0001050759 , 差值是否夠小: FALSE 
已經做 10 次了但差值 0.0001050759 仍未小於 1e-10 所以自我遞迴重做一次 
iter = 1 , x = 10.17767 next x = 6.872 , 差值 = 3.305667 , 差值是否夠小: FALSE 
iter = 2 , x = 6.872 next x = 4.77192 , 差值 = 2.10008 , 差值是否夠小: FALSE 
iter = 3 , x = 4.77192 next x = 3.57653 , 差值 = 1.19539 , 差值是否夠小: FALSE 
iter = 4 , x = 3.57653 next x = 3.087968 , 差值 = 0.4885623 , 差值是否夠小: FALSE 
iter = 5 , x = 3.087968 next x = 3.002517 , 差值 = 0.0854509 , 差值是否夠小: FALSE 
iter = 6 , x = 3.002517 next x = 3.000039 , 差值 = 0.002478053 , 差值是否夠小: FALSE 
iter = 7 , x = 3.000039 next x = 3.000037 , 差值 = 2.048016e-06 , 差值是否夠小: FALSE 
iter = 8 , x = 3.000037 next x = 3.000037 , 差值 = 1.397993e-12 , 差值是否夠小: TRUE 
達到標準; 完成

[1] 3.000037
https://ideone.com/r6DFbj
language:
R (R 3.5.2)
created:
3 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!