一百個例題 ( 66 ~ 70 )
Ching-Tang Tseng
Hamilton, New Zealand
24 September 2024
FORTH:慶的世界。 本網頁為中華民國(Republic Of China)FORTH語言協會 永久性網頁
2024年9月23日 星期一
第(66)個範例，是兩個展示叫用自己的自用副程式(recursive)如何使用的簡例。
第一個所舉之例，可用來求解出兩個數字的最大公約數。利用輾轉相除法，互相除到 0 前的最後數字，就是最大公約數。
Forth 的程式寫法，就是這麼簡單，只需一列程式，簡單到非常容易看懂，簡單到幾乎不需要寫說明來解釋的必要。
但是，如果我不指出一些叫用自己之自用副程式寫法上該注意的要點，大家可能光看這個程式，還是很難理解。
第二個所舉之例，是以運用自用副程式的方式，設計『一個從 1 加到 n 之總和為多少？』的程式，例如：從 1 加到 10 得 55 ，如何設計這種程式？。
使用自用副程式時，該注意的關鍵要點為：必須有結束叫用自己的機制，否則程式的執行會循環不已而令系統崩潰。
這兩個例題中終結叫用自己的機制都被安排在邏輯指令組中的 if ,,,,, then 之前的 ?dup ，一旦達到終止條件的要求，就可以不再以叫用自己的方式結束程式。 if 之前的 ?dup 出現 0 時，會產生終結條件，程式便不再執行 if ..... then 之間的程式，也就結束了 recurse 。
:
第一個所舉之例，可用來求解出兩個數字的最大公約數。利用輾轉相除法，互相除到 0 前的最後數字，就是最大公約數。
Forth 的程式寫法，就是這麼簡單，只需一列程式，簡單到非常容易看懂，簡單到幾乎不需要寫說明來解釋的必要。
但是，如果我不指出一些叫用自己之自用副程式寫法上該注意的要點，大家可能光看這個程式，還是很難理解。
第二個所舉之例，是以運用自用副程式的方式，設計『一個從 1 加到 n 之總和為多少？』的程式，例如：從 1 加到 10 得 55 ，如何設計這種程式？。
使用自用副程式時，該注意的關鍵要點為：必須有結束叫用自己的機制，否則程式的執行會循環不已而令系統崩潰。
這兩個例題中終結叫用自己的機制都被安排在邏輯指令組中的 if ,,,,, then 之前的 ?dup ，一旦達到終止條件的要求，就可以不再以叫用自己的方式結束程式。 if 之前的 ?dup 出現 0 時，會產生終結條件，程式便不再執行 if ..... then 之間的程式，也就結束了 recurse 。
:
\ (66)RecursiveGCD.f : GCD ( n1 n2 -- n3 ) ?DUP IF SWAP OVER MOD RECURSE THEN ; variable TotalSum : n- ( n -- ) ?dup if dup TotalSum +! 1- recurse then ; : ss ( n -- ) 0 TotalSum ! n- TotalSum @ . ;
第(67)範例是一個新冠疫情初起時用來預卜次日確診人數的指數回歸(exponential regression)分析程式。
2020 年初，新冠病毒疫情之事，吵得沸沸揚揚，網上言論無數，嚇壞了大家，搞得全台灣連口罩都被戒嚴處理，無處可買，實在好笑。我對這些事情沒有興趣，但也不甘寂寞，對涉及濫用數學理論曲解問題的胡扯言論，不以為然。這次事件給了我一套可貴的實際數據，能用於程式測試，這才是我真正感興趣的地方。平時，我若研究數學問題，很難獲得實際有意義的數據來配合測試，數據都是一長串的數字，自己亂造，肯定不太合理，官方發佈的數據，就絕對可取。收集數據是長期的工作，早收集也沒有，晚收集會消失，只能每天固定在早上起床後立刻做，做了好幾天，都是有用的東西，非常可貴。
事件剛開始時，台灣反中，政府藉機恐嚇群眾，用了一個指數函數的傳染病增長模式來恐嚇大家，照那套講法，一個月內就會有幾千萬人的災難發生。過了一個多月，中國沒有發生胡扯的結果，可見年初台灣發表恐嚇言論者的可惡。不久，台灣也染上了病毒，按照同樣的講法，一個月內全台灣都會感染，可能嗎？不可能。
本來，描訴疫情應該使用的數學模式叫 Logistic function 不是 exponential function 。但在疫情初起時，沒有真正的數據可供進行曲線調適來算出 Logistic function ，當時所能預估的事情，也只能以指數回歸算法預測次日的可能確診人數。
上述兩種數學模式的初起階段，變化近似，所以在現象尚未進行到超過數學上所謂的曲線之拐點(inflection point)以前，兩者近似，過了拐點，結論就會完全不同。我在收集了十天數據之後，開始設計這個指數函數的回歸分析程式，並用來直接預測次日結果，雖未中的，但趨勢不變，誤差不大。
可以預知之更後來的情形，就是一旦指數回歸分析預卜出來的數字逐漸高出實際確診人數越來越多時，就能確定疫情的拐點已經出現。後半部的演變，會是第三象限曲線以原點為樞紐表現於第一象限的對稱曲線，兩者合併起來，就是 Logistic function 。
指數函數的形式是這樣的：
y(t) = a * exp ( b * t ) 其中
t 表時間，以天為單位。n 為所取數據組的數量，此例為 10 組。
a 及 b 均為係數，在取得此函數式的 n 組相關數據後，藉統計學上的回歸(regression)分析技術，就能算出這兩個係數的值，相關公式如下：
b = [ n * SUM { Xi * ln ( Yi ) } - ( SUM Xi ) * { SUM ln ( Yi ) } ]
/ [ n * SUM ( Xi ^ 2 ) - ( SUM Xi ) ^ 2 ]
a = exp [ (1/n) * { SUM ( ln Yi ) - b * ( SUM Ei ) } ]
相應的程式如下：
:
2020 年初，新冠病毒疫情之事，吵得沸沸揚揚，網上言論無數，嚇壞了大家，搞得全台灣連口罩都被戒嚴處理，無處可買，實在好笑。我對這些事情沒有興趣，但也不甘寂寞，對涉及濫用數學理論曲解問題的胡扯言論，不以為然。這次事件給了我一套可貴的實際數據，能用於程式測試，這才是我真正感興趣的地方。平時，我若研究數學問題，很難獲得實際有意義的數據來配合測試，數據都是一長串的數字，自己亂造，肯定不太合理，官方發佈的數據，就絕對可取。收集數據是長期的工作，早收集也沒有，晚收集會消失，只能每天固定在早上起床後立刻做，做了好幾天，都是有用的東西，非常可貴。
事件剛開始時，台灣反中，政府藉機恐嚇群眾，用了一個指數函數的傳染病增長模式來恐嚇大家，照那套講法，一個月內就會有幾千萬人的災難發生。過了一個多月，中國沒有發生胡扯的結果，可見年初台灣發表恐嚇言論者的可惡。不久，台灣也染上了病毒，按照同樣的講法，一個月內全台灣都會感染，可能嗎？不可能。
本來，描訴疫情應該使用的數學模式叫 Logistic function 不是 exponential function 。但在疫情初起時，沒有真正的數據可供進行曲線調適來算出 Logistic function ，當時所能預估的事情，也只能以指數回歸算法預測次日的可能確診人數。
上述兩種數學模式的初起階段，變化近似，所以在現象尚未進行到超過數學上所謂的曲線之拐點(inflection point)以前，兩者近似，過了拐點，結論就會完全不同。我在收集了十天數據之後，開始設計這個指數函數的回歸分析程式，並用來直接預測次日結果，雖未中的，但趨勢不變，誤差不大。
可以預知之更後來的情形，就是一旦指數回歸分析預卜出來的數字逐漸高出實際確診人數越來越多時，就能確定疫情的拐點已經出現。後半部的演變，會是第三象限曲線以原點為樞紐表現於第一象限的對稱曲線，兩者合併起來，就是 Logistic function 。
指數函數的形式是這樣的：
y(t) = a * exp ( b * t ) 其中
t 表時間，以天為單位。n 為所取數據組的數量，此例為 10 組。
a 及 b 均為係數，在取得此函數式的 n 組相關數據後，藉統計學上的回歸(regression)分析技術，就能算出這兩個係數的值，相關公式如下：
b = [ n * SUM { Xi * ln ( Yi ) } - ( SUM Xi ) * { SUM ln ( Yi ) } ]
/ [ n * SUM ( Xi ^ 2 ) - ( SUM Xi ) ^ 2 ]
a = exp [ (1/n) * { SUM ( ln Yi ) - b * ( SUM Ei ) } ]
相應的程式如下：
:
\ (67)exponential regression
2 integers n i
9 reals s1 s2 s3 s4 s5 x y a b
20 array xx
20 array yy
: initialize
basic
10 let { s1 = 0.0e0 }
20 let { s2 = s1 }
30 let { s3 = s1 }
40 let { s4 = s1 }
50 let { s5 = s1 }
60 end
;
: InputData
basic
10 let n = 9
20 let { xx ( 0 ) = 0.0e0 } :: { yy ( 0 ) = 291.0e0 }
30 let { xx ( 1 ) = 1.0e0 } :: { yy ( 1 ) = 324.0e0 }
40 let { xx ( 2 ) = 2.0e0 } :: { yy ( 2 ) = 571.0e0 }
50 let { xx ( 3 ) = 3.0e0 } :: { yy ( 3 ) = 830.0e0 }
60 let { xx ( 4 ) = 4.0e0 } :: { yy ( 4 ) = 1287.0e0 }
70 let { xx ( 5 ) = 5.0e0 } :: { yy ( 5 ) = 1975.0e0 }
80 let { xx ( 6 ) = 6.0e0 } :: { yy ( 6 ) = 2744.0e0 }
90 let { xx ( 7 ) = 7.0e0 } :: { yy ( 7 ) = 4599.0e0 }
100 let { xx ( 8 ) = 8.0e0 } :: { yy ( 8 ) = 6078.0e0 }
200 end
;
: regression
basic
10 run initialize InputData
20 for i = 0 to n - 1
30 let { x = xx ( i ) }
40 let { y = ln ( yy ( i ) ) }
50 let { s1 = s1 + x }
60 let { s2 = s2 + y }
70 let { s3 = s3 + x * x }
80 let { s4 = s4 + y * y }
90 let { s5 = s5 + x * y }
100 next i
110 let { b = ( i>r ( n ) * s5 - s2 * s1 ) / ( i>r ( n ) * s3 - s1 * s1 ) }
120 let { a = exp ( ( s2 - B * s1 ) / i>r ( n ) ) }
130 print " exponential regression: y = a * exp ( b * t ) "
140 run cr ." a = " a f.
150 run cr ." b = " b f. cr
160 let { y = a * exp ( b * 8.0e0 ) }
170 run cr ." y(8) = " y f. cr
180 let { y = a * exp ( b * 9.0e0 ) }
190 run cr ." y(9) = " y f. cr
200 end
;
regression
\s
程式的執行結果如下：
exponential regression: y = a * exp ( b * t )
a = 254.72339048
b = 0.4020241052
y(8) = 6351.0221997
y(9) = 9493.8088062
第(68)個範例，是一個能自動將數字的因數全部分解出來，改寫成質數連乘等式的程式。
程式中列示源程式的來源，是一個法國人列寧(Lehning，跟馬克斯沒有關係)，於 1982 年捐贈給巴黎數學機構的公益程式。我自創的 ABC Forth 很輕易的就能改寫完成，而且到處應用。我的個人網頁網文中，有一篇『因數分解美國總統』的諷刺性技術貼文，就用這個程式。
深究我自創系統的性能，有一項功能是一般傳統 BASIC 所不能比的。也就是在固定循環指標量非常大時，如果循環內有邏輯判斷判定出可以不必再循環下去的條件時，我的系統有辦法以非結構化的方式跳出迴路，可以不必繼續執行剩餘的天文數字循環指標量，可以大量節省執行時間。
一般人設計系統，為了迎合『結構化』的條件，就絕對無法辦到我設計的這項功能。此前，全世界除了組合語言的天生可以亂跳之功能也可以如此之外，我沒見過任何程式語言能有這種性能。
這套判斷數字是否為質數的原理很普及，但我們在學校裡的教科書全部不寫、不教，我是在大學畢業後，買了全套三本的『數學之內容方法及意義』書籍，從其中的第十章之『數論』章節內學來的，大家可能沒這些書，細節我就不寫了，只告訴大家，這是一個古希臘的數學家 Eratosthenes (西元前 276 年到西元前 194 )，所提出的『篩選』法。也就是大約就在孔子(西元前 551 年到西元前 479 年)死後沒多久， Eratosthenes 就知道怎麼搞了，他還知道如何利用太陽光線直射的角度，來測量地球的圓周有多長？頭腦真不簡單。
篩選法就是：先用 2 試，再用 3 試，如果都不能除得盡，就再用 6i-1 與 6i+1 繼續試，其中 i 是從 1 開始的整數，一直試到被測數的開平方為止，如果全都除不盡，那 麼，這個數字本身就是個質數。
沒人能證明質數的總量是有限個，我們的電腦可以使用的單整數越來越大，現在 64 位元可有 18 位數，已大到非常驚人，我為了想證明這個方法找出的質數依然有效，我就寫過程式，讓我的電腦跑 18 位數整數的測量，還真有效呢！我也能寫 18 位數以上的測量程式，會讓電腦跑到冷卻風扇一直全速運轉，電腦就累死了，也熱死了，為了不把電腦搞壞，只好壓 ctrl+C 結束系統的執行了。
這個程式的道理很簡單，在許多方面也都可以繼續延伸性的使用，它不僅是留下來的範例，常被我挑出來活用，我程式中的說明也很清楚，每次使用時，都可以不花腦筋的套進我的新程式中，這就是 BASIC 式程式語言的最大好處。
:
程式中列示源程式的來源，是一個法國人列寧(Lehning，跟馬克斯沒有關係)，於 1982 年捐贈給巴黎數學機構的公益程式。我自創的 ABC Forth 很輕易的就能改寫完成，而且到處應用。我的個人網頁網文中，有一篇『因數分解美國總統』的諷刺性技術貼文，就用這個程式。
深究我自創系統的性能，有一項功能是一般傳統 BASIC 所不能比的。也就是在固定循環指標量非常大時，如果循環內有邏輯判斷判定出可以不必再循環下去的條件時，我的系統有辦法以非結構化的方式跳出迴路，可以不必繼續執行剩餘的天文數字循環指標量，可以大量節省執行時間。
一般人設計系統，為了迎合『結構化』的條件，就絕對無法辦到我設計的這項功能。此前，全世界除了組合語言的天生可以亂跳之功能也可以如此之外，我沒見過任何程式語言能有這種性能。
這套判斷數字是否為質數的原理很普及，但我們在學校裡的教科書全部不寫、不教，我是在大學畢業後，買了全套三本的『數學之內容方法及意義』書籍，從其中的第十章之『數論』章節內學來的，大家可能沒這些書，細節我就不寫了，只告訴大家，這是一個古希臘的數學家 Eratosthenes (西元前 276 年到西元前 194 )，所提出的『篩選』法。也就是大約就在孔子(西元前 551 年到西元前 479 年)死後沒多久， Eratosthenes 就知道怎麼搞了，他還知道如何利用太陽光線直射的角度，來測量地球的圓周有多長？頭腦真不簡單。
篩選法就是：先用 2 試，再用 3 試，如果都不能除得盡，就再用 6i-1 與 6i+1 繼續試，其中 i 是從 1 開始的整數，一直試到被測數的開平方為止，如果全都除不盡，那 麼，這個數字本身就是個質數。
沒人能證明質數的總量是有限個，我們的電腦可以使用的單整數越來越大，現在 64 位元可有 18 位數，已大到非常驚人，我為了想證明這個方法找出的質數依然有效，我就寫過程式，讓我的電腦跑 18 位數整數的測量，還真有效呢！我也能寫 18 位數以上的測量程式，會讓電腦跑到冷卻風扇一直全速運轉，電腦就累死了，也熱死了，為了不把電腦搞壞，只好壓 ctrl+C 結束系統的執行了。
這個程式的道理很簡單，在許多方面也都可以繼續延伸性的使用，它不僅是留下來的範例，常被我挑出來活用，我程式中的說明也很清楚，每次使用時，都可以不花腦筋的套進我的新程式中，這就是 BASIC 式程式語言的最大好處。
:
\ factors.f (( '********************************************* '* Factorization of an integer number * '* ----------------------------------------- * '* Sample run: * '* * '* ? 394616 * '* * '* 2 2 2 107 461 * '* * '* ----------------------------------------- * '* Ref.: "Mathmatiques par l'informatique * '* individuelle (1) By H. Lehning * '* et D. Jakubowicz, Masson, Paris, * '* 1982" [BIBLI 06]. * '********************************************* )) 4 integers N D I L : test page basic 10 print " Enter integer number to be factorized " 20 inputi N \ 'Test if multiple of 2 40 let D = N mod 2 50 if D = 0 then 70 60 goto 100 70 print 2 80 let N = N / 2 90 goto -40 \ 'Test if multiple of 3 100 let D = N mod 3 110 if D = 0 then 130 120 goto 200 130 print 3 140 let N = N / 3 150 goto -100 \ 'Test of divisors 6i-1 and 6i+1 up to sqr(N) \ 'Prime numbers are of the form 6i-1 or 6i+1 200 let L = sqrt ( N ) + 1 210 for I = 6 to L step 6 220 let D = N mod ( I - 1 ) 230 if D = 0 then 250 240 goto 300 250 print ( I - 1 ) 260 let N = N / ( I - 1 ) 270 goto -220 300 let D = N mod ( I + 1 ) 310 if D = 0 then 330 320 goto 400 330 print ( I + 1 ) 340 let N = N / ( I + 1 ) 350 goto -300 400 next I 500 if N > 1 then 520 510 goto 600 520 print N 600 end ;
第(69)個範例是源自於他種程式語言有此用法的 Forth 等效設計，叫『局部副程式』(quotations)設計技術。
局部副程式只是我個人的譯名，取其意義而譯。
這套技術，是遲至前幾年才出現的術語，只因有些慣用其他程式語言的闖入者，拿這種術語考驗 Forth 老手，於是，在國際論壇上展開過一陣子論戰。末了，有人捐獻了這麼一個精簡設計，我錄下了這份技術。當然，取用之初， Win32Forth 是跑不通的。我看得懂它在談什麼，就依理改出了這個檔案，當作範例留參。
所謂『局部』，也就是這種用法，只能在單一個指令的設計範圍內有效，出界就不能再用，不能給別的指令設計時使用。『副程式』就是可以像巨集指令那樣，在本指令範圍內，不斷地被重複叫用，叫用幾次都可以執行。
為什麼要強調這樣的功能？
別種程式語言的程式設計方法與格式，通常都非常龐大、複雜。如果發現整個程式中，有許多片段，都是同樣的語法及內容，就會希望同樣片段只需寫一次程式就夠了，後續若再需要時，只需取得該片段程式的起始執行位址，填在各個一再使用之處，就能完成設計。
這麼簡單的執行邏輯，是難不倒 Forth 熟手的，能解決的先決條件，就是得非常熟悉 Forth 系統內部的結構，就能輕易實現等效功能。
它在 Forth 系統中的用法，是將特定片段的起始執行位址，放在數據堆疊上，待後續想再用到之處，將此執行位址，推放到回返堆疊上去，就完成了工作。待您執行設計好的指令時，重複使用的片段，都能一一被執行出指定的結果。如果您還不能體會這種意義，那麽，請在最後一個 >exec 前面，多添加一列 『 dup >exec 』後，重新編譯再執行 greet 指令試試看，您會見到印出了兩次 『 world 』這個字，不是只有一次，這就是效果。
實際上，我在 FigTaiwan 論壇上，捐獻過其他類似的設計，只因我熟知系統結構，設計都很簡短。有人提問，能否在 Win32Forth 系統中實現 in-line assembly 的功能，問題本該由 Forth 老手提供解答服務，我看到等了好幾天沒人理會，就動手寫了一個，公開貼出，這種問題對我而言，不是大問題。但我不喜歡這樣用這種技術，那會把程式搞得非常混亂，難以看懂。所以我也不鼓勵大家這樣寫程式，除非一定需要在某處高速、高效執行程式，否則不必硬要這樣寫程式。當然，我也能設計出能在組合語言中突然轉用高階指令插入程式設計之處的古怪程式，也是沒有必要這樣做。
事實上，這個局部副程式的設計方法，根本沒必要存在。因為想這樣用時，還不如就在指令外面另外設計必須反覆使用的部分，給它一個名稱就可以了。後續指令想怎麼用？想用多少次？就都可以悉聽尊便。這本就是 Forth 的基本精神，何須多此一舉又搞一個 quotation 來煩自己？
:
局部副程式只是我個人的譯名，取其意義而譯。
這套技術，是遲至前幾年才出現的術語，只因有些慣用其他程式語言的闖入者，拿這種術語考驗 Forth 老手，於是，在國際論壇上展開過一陣子論戰。末了，有人捐獻了這麼一個精簡設計，我錄下了這份技術。當然，取用之初， Win32Forth 是跑不通的。我看得懂它在談什麼，就依理改出了這個檔案，當作範例留參。
所謂『局部』，也就是這種用法，只能在單一個指令的設計範圍內有效，出界就不能再用，不能給別的指令設計時使用。『副程式』就是可以像巨集指令那樣，在本指令範圍內，不斷地被重複叫用，叫用幾次都可以執行。
為什麼要強調這樣的功能？
別種程式語言的程式設計方法與格式，通常都非常龐大、複雜。如果發現整個程式中，有許多片段，都是同樣的語法及內容，就會希望同樣片段只需寫一次程式就夠了，後續若再需要時，只需取得該片段程式的起始執行位址，填在各個一再使用之處，就能完成設計。
這麼簡單的執行邏輯，是難不倒 Forth 熟手的，能解決的先決條件，就是得非常熟悉 Forth 系統內部的結構，就能輕易實現等效功能。
它在 Forth 系統中的用法，是將特定片段的起始執行位址，放在數據堆疊上，待後續想再用到之處，將此執行位址，推放到回返堆疊上去，就完成了工作。待您執行設計好的指令時，重複使用的片段，都能一一被執行出指定的結果。如果您還不能體會這種意義，那麽，請在最後一個 >exec 前面，多添加一列 『 dup >exec 』後，重新編譯再執行 greet 指令試試看，您會見到印出了兩次 『 world 』這個字，不是只有一次，這就是效果。
實際上，我在 FigTaiwan 論壇上，捐獻過其他類似的設計，只因我熟知系統結構，設計都很簡短。有人提問，能否在 Win32Forth 系統中實現 in-line assembly 的功能，問題本該由 Forth 老手提供解答服務，我看到等了好幾天沒人理會，就動手寫了一個，公開貼出，這種問題對我而言，不是大問題。但我不喜歡這樣用這種技術，那會把程式搞得非常混亂，難以看懂。所以我也不鼓勵大家這樣寫程式，除非一定需要在某處高速、高效執行程式，否則不必硬要這樣寫程式。當然，我也能設計出能在組合語言中突然轉用高階指令插入程式設計之處的古怪程式，也是沒有必要這樣做。
事實上，這個局部副程式的設計方法，根本沒必要存在。因為想這樣用時，還不如就在指令外面另外設計必須反覆使用的部分，給它一個名稱就可以了。後續指令想怎麼用？想用多少次？就都可以悉聽尊便。這本就是 Forth 的基本精神，何須多此一舉又搞一個 quotation 來煩自己？
:
\ quotation.f
: ends> r> ;
: end >r ; immediate
\ quotations: 局部副程式
: >EXEC >R ; \ for Win32Forth only
: [:
postpone ahead here -rot
ends> postpone exit postpone then postpone literal
; immediate
: ;] >r ; immediate \ or an alias of end
: greet [: ." world" ;]
." hello"
>exec ; \ for Win32forth
\ execute ; \ for other forth
第(70)個範例，總共有 8 個依序發展出來的等效程式。
前四個是單純用來判斷一個數字是否為質數的程式，判斷方法，第(68)個範例中已經說明過了。
第一個是最原始的寫法，不求精簡，也不求快速，容易看懂，放諸四海而皆準，不管系統為多少位元，全都有效。
第二個寫法，把所有的邏輯判斷方式都精簡化了，但全仍照根本原則設計程式，適合用來理解語法的精要。
第三個程式，開始添加了 outrun 指令 ，強調『逸出定量迴路法』。 這是目前所有其他種程式語言所沒有的性能。主要的關鍵，是我把迴路指標設計成放在普通的數據堆疊上，所以，我自創的系統才能這樣做。請注意，傳統的 Forth 系統，把『DO ..... LOOP』迴路的指摽，放在回返堆疊上，也能這樣做，但要熟悉系統的人，才有本領照樣做。隨著系統的不同，放法不一，所以， Forth 也不能寫成通用教材來教育大家。我自創的系統，可以。
第四個程式，發展出了對指定範圍內所有數字進行測試的程式。 32 位元情況時之測試記錄，留在程式下方，供作參考。
第五到第八個程式，名稱都改為 PRange 了，但是，他們都是後來適用於 64 位元環境的大型測試用程式。主要運作的系統，是 Lina64 。我不喜歡別種不透明系統的環境，所以只採用完全透明的 Lina64 。
不要小看這一系列的發展進程，我是下了功夫仔細研究過許久的人，知道其中的意義與功效。舉例來說，我在研究純粹以四則運算法設計亂數時，很需要使用一個許多位數的質數來配合應用，所產出的亂數品質才能夠好。若沒有這一系列的工具，你什麼事也別想進行。以前，中山科學研究院請日本技師來為 CDC 大型電腦主機安裝亂數產生程式時，據說，當時是論多少百萬台幣付費的，安裝時，使用硬體裝備灌進記憶體裡燒死，那個關鍵質數放在技師的口袋裡，沒有人在旁的時候，他才 1010 的敲進去。這個質數，若沒有經過大量、長時間的評鑑測試，不敢提出來賣這麼多錢。現在，我的程式，就可以做這件事情。
另外，我曾經在田納西大學的質數網站發現，這所大學花了不少錢，為 54 (非64) 位元以下的質數，建立了不知有多少頁的質數表格，供全世界查用。需要這樣嗎？也許以前紙本書的時代確實需要，不要怪這所名校浪費金錢，畢竟，並不是人人都能像我這樣用 Forth 自創系統，自寫程式，隨時可以得到這方面想要的東西。就算我現在把程式都在網上公開貼出了許久，會用 Forth 的人越來越少，我又不想再搞推廣，能用的，還有幾人？
為了驗證第(68)個範例中所說的所有質數都能寫成 6i+1 或 6i-1 (或 6i+5 )的格式，我也下了功夫，以程式核實，讓系統從頭跑到底，把 64 位元以下所有的質數查證一遍，自動告訴我，有沒有那一個不能寫成這兩種格式的質數？這就形同使用電腦進行全程自動執行的『數學歸納法』驗證數學理論，結果，真是如那個希臘數學家所言：『確實是都行』。留下的這些範例中，最後一個範例 PRange4.f ，就是在做這件事情。
20240927 我在 Twitter 網站上看到這個貼文：100,000,001 can be divided by 17. 我立刻載入因數分解出質數的程式，得知 1,0000,0001 ＝ 17 * 5882353 。 別說一億零一了，一千兆零一，我也能立刻得到答案： 1000,0000,0000,0001 = 7 * 11 * 13 * 211 * 241 * 2161 * 9091 。學而時習之，不亦樂乎？
探討質數的理論可以延伸出無數的問體，以後，我還可能遭遇到與質數理論相關的更多問題，這些東西也都還有用處，實際發展出來的程式就代表了我研究問題時的精神。
:
前四個是單純用來判斷一個數字是否為質數的程式，判斷方法，第(68)個範例中已經說明過了。
第一個是最原始的寫法，不求精簡，也不求快速，容易看懂，放諸四海而皆準，不管系統為多少位元，全都有效。
第二個寫法，把所有的邏輯判斷方式都精簡化了，但全仍照根本原則設計程式，適合用來理解語法的精要。
第三個程式，開始添加了 outrun 指令 ，強調『逸出定量迴路法』。 這是目前所有其他種程式語言所沒有的性能。主要的關鍵，是我把迴路指標設計成放在普通的數據堆疊上，所以，我自創的系統才能這樣做。請注意，傳統的 Forth 系統，把『DO ..... LOOP』迴路的指摽，放在回返堆疊上，也能這樣做，但要熟悉系統的人，才有本領照樣做。隨著系統的不同，放法不一，所以， Forth 也不能寫成通用教材來教育大家。我自創的系統，可以。
第四個程式，發展出了對指定範圍內所有數字進行測試的程式。 32 位元情況時之測試記錄，留在程式下方，供作參考。
第五到第八個程式，名稱都改為 PRange 了，但是，他們都是後來適用於 64 位元環境的大型測試用程式。主要運作的系統，是 Lina64 。我不喜歡別種不透明系統的環境，所以只採用完全透明的 Lina64 。
不要小看這一系列的發展進程，我是下了功夫仔細研究過許久的人，知道其中的意義與功效。舉例來說，我在研究純粹以四則運算法設計亂數時，很需要使用一個許多位數的質數來配合應用，所產出的亂數品質才能夠好。若沒有這一系列的工具，你什麼事也別想進行。以前，中山科學研究院請日本技師來為 CDC 大型電腦主機安裝亂數產生程式時，據說，當時是論多少百萬台幣付費的，安裝時，使用硬體裝備灌進記憶體裡燒死，那個關鍵質數放在技師的口袋裡，沒有人在旁的時候，他才 1010 的敲進去。這個質數，若沒有經過大量、長時間的評鑑測試，不敢提出來賣這麼多錢。現在，我的程式，就可以做這件事情。
另外，我曾經在田納西大學的質數網站發現，這所大學花了不少錢，為 54 (非64) 位元以下的質數，建立了不知有多少頁的質數表格，供全世界查用。需要這樣嗎？也許以前紙本書的時代確實需要，不要怪這所名校浪費金錢，畢竟，並不是人人都能像我這樣用 Forth 自創系統，自寫程式，隨時可以得到這方面想要的東西。就算我現在把程式都在網上公開貼出了許久，會用 Forth 的人越來越少，我又不想再搞推廣，能用的，還有幾人？
為了驗證第(68)個範例中所說的所有質數都能寫成 6i+1 或 6i-1 (或 6i+5 )的格式，我也下了功夫，以程式核實，讓系統從頭跑到底，把 64 位元以下所有的質數查證一遍，自動告訴我，有沒有那一個不能寫成這兩種格式的質數？這就形同使用電腦進行全程自動執行的『數學歸納法』驗證數學理論，結果，真是如那個希臘數學家所言：『確實是都行』。留下的這些範例中，最後一個範例 PRange4.f ，就是在做這件事情。
20240927 我在 Twitter 網站上看到這個貼文：100,000,001 can be divided by 17. 我立刻載入因數分解出質數的程式，得知 1,0000,0001 ＝ 17 * 5882353 。 別說一億零一了，一千兆零一，我也能立刻得到答案： 1000,0000,0000,0001 = 7 * 11 * 13 * 211 * 241 * 2161 * 9091 。學而時習之，不亦樂乎？
探討質數的理論可以延伸出無數的問體，以後，我還可能遭遇到與質數理論相關的更多問題，這些東西也都還有用處，實際發展出來的程式就代表了我研究問題時的精神。
:
\ prime1.f
4 integers D N L I
: test
basic
10 print " Input an integer number N = "
20 inputi N
30 let D = N mod 2
40 if D = 0 then 220
50 let D = N mod 3
60 if D = 0 then 220
70 let L = sqrt ( N ) + 1
80 for I = 6 to L step 6
90 let D = N mod ( I - 1 )
100 if D = 0 then 210
110 let D = N mod ( I + 1 )
120 if D = 0 then 210
130 next I
140 print N ; " is a prime number."
150 goto 300
210 run 2drop
220 print N ; " is not a prime number."
300 end ;
\ prime2.f
3 integers N I L
: outrun 2drop ;
: test
PAGE
BASIC
10 print " Input an integer number N = "
20 inputi N
30 if ( N mod 2 = 0 ) OR ( N mod 3 = 0 ) then 220
40 let L = sqrt ( N ) + 1
50 for I = 6 to L step 6
60 if ( N mod ( I - 1 ) = 0 ) OR ( N mod ( I + 1 ) = 0 ) then 210
70 next I
110 print " Yes, " ; N ; " is a prime number."
120 goto 300
210 run outrun
220 print " No, " ; N ; " is not a prime number."
300 end ;
\S
test
Input an integer number N : ? 600
No, 600 is not a prime number. ok
test
Input an integer number N : ? 1999
Yes, 1999 is a prime number. ok
\ prime3.f
6 integers N I J L C D
: outrun 2drop ;
: test
PAGE
BASIC
10 print " Input start and stop numbers C and D = "
20 inputi C , D
30 for J = C to D
40 let N = J
50 if ( N mod 2 = 0 ) OR ( N mod 3 = 0 ) then 220
60 let L = sqrt ( N ) + 1
70 for I = 6 to L step 6
80 if ( N mod ( I - 1 ) = 0 ) OR ( N mod ( I + 1 ) = 0 ) then 210
90 next I
110 print N
120 goto 220
210 run outrun
220 next J
300 end ;
TEST
\ prime4.f
6 integers N I J L C D
: outrun 2drop ;
: test
PAGE
BASIC
10 print " Input start and stop numbers C and D = "
20 inputi C , D
30 for J = C to D
40 let N = J
50 if N mod 2 = 0 then 220
60 if N mod 3 = 0 then 220
70 let L = sqrt ( N ) + 1
80 for I = 6 to L step 6
90 if N mod ( I - 1 ) = 0 then 210
100 if N mod ( I + 1 ) = 0 then 210
110 next I
120 print N
130 goto 220
210 run outrun
220 next J
300 end ;
TEST
\S
testing range must be <= 2147483647 ( get it from -1 1 rshift . )
Input start and stop numbers C and D = ? 1999999000 2000000000
1999999003
1999999013
1999999049
1999999061
1999999081
1999999087
1999999093
1999999097
1999999117
1999999121
1999999151
1999999171
1999999207
1999999219
1999999271
1999999321
1999999373
1999999423
1999999439
1999999499
1999999553
1999999559
1999999571
1999999609
1999999613
1999999621
1999999643
1999999649
1999999657
1999999747
1999999763
1999999777
1999999811
1999999817
1999999829
1999999853
1999999861
1999999871
1999999873
1999999913
1999999927
1999999943
1999999973
\ prange1.f use \lina64\nfp2\f5102
6 integers N I J L A B
: outrun 2drop ;
: test
BASIC
10 print " Input start and stop numbers A and B = "
20 inputi A , B
30 for J = A to B
40 let N = J
50 if ( N mod 2 = 0 ) OR ( N mod 3 = 0 ) then 220
60 let L = sqrt ( N ) + 1
70 for I = 6 to L step 6
80 if ( N mod ( I - 1 ) = 0 ) OR ( N mod ( I + 1 ) = 0 ) then 210
90 next I
110 print N
120 goto 220
210 run outrun
220 next J
300 end ;
TEST
\S
Input start and stop numbers A and B =
? 1000000000001000 1000000000002000
1000000000001003
1000000000001027
1000000000001063
1000000000001089
1000000000001117
1000000000001209
1000000000001269
1000000000001293
1000000000001347
1000000000001371
1000000000001413
1000000000001491
1000000000001503
1000000000001551
1000000000001617
1000000000001623
1000000000001669
1000000000001741
1000000000001749
1000000000001819
1000000000001839
1000000000001867
1000000000001897 OK
\ prange2.f use \lina64\nfp2\f5102
6 integers N I J L A B
: outrun 2drop ;
: test
BASIC
10 print " Input start and stop numbers A and B = "
20 inputi A , B
30 for J = A to B
40 let N = J
50 if N mod 2 = 0 then 220
60 if N mod 3 = 0 then 220
70 let L = sqrt ( N ) + 1
80 for I = 6 to L step 6
90 if N mod ( I - 1 ) = 0 then 210
100 if N mod ( I + 1 ) = 0 then 210
110 next I
120 print N
130 goto 220
210 run outrun
220 next J
300 end ;
TEST
\S
Input start and stop numbers A and B =
? 1000000000001000 1000000000002000
1000000000001003
1000000000001027
1000000000001063
1000000000001089
1000000000001117
1000000000001209
1000000000001269
1000000000001293
1000000000001347
1000000000001371
1000000000001413
1000000000001491
1000000000001503
1000000000001551
1000000000001617
1000000000001623
1000000000001669
1000000000001741
1000000000001749
1000000000001819
1000000000001839
1000000000001867
1000000000001897 OK
\ prange3.f use \lina64\nfp2\f5102
7 integers N I J L A B C
: outrun 2drop ;
: test
BASIC
10 print " Input start and stop numbers A and B = "
20 inputi A , B
30 LET C = 0
40 for J = A to B
50 let N = J
60 if N mod 2 = 0 then 220
70 if N mod 3 = 0 then 220
80 let L = sqrt ( N ) + 1
90 for I = 6 to L step 6
100 if N mod ( I - 1 ) = 0 then 210
110 if N mod ( I + 1 ) = 0 then 210
120 next I
130 LET C = C + 1
140 print N
150 goto 220
210 run outrun
220 next J
230 PRINT " total = " ; C
300 end ;
TEST
\S
Input start and stop numbers A and B =
? 1000000000001000 1000000000002000
1000000000001003
1000000000001027
1000000000001063
1000000000001089
1000000000001117
1000000000001209
1000000000001269
1000000000001293
1000000000001347
1000000000001371
1000000000001413
1000000000001491
1000000000001503
1000000000001551
1000000000001617
1000000000001623
1000000000001669
1000000000001741
1000000000001749
1000000000001819
訂閱：
張貼留言 (Atom)
沒有留言:
張貼留言