Script Programming(스크립트 프로그래밍)

다음은  대화형 모드(interactive mode)에서 진법 변환(radix conversion)하는 F# 소스 코드이다.

   주: 이 소스는 Python 용으로 만들어 둔 소스를 F# 언어로 바꾼 것이라서
        F# 언어의 명령형 언어 특징을 위주로 짜여져 있다.

메뉴는 주메뉴 Command: (S)et radix, (A)bout, (Q)uit or E(x)it
와 부메뉴 SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit
로 구성되어 있으며, 진법 변환의 핵심은 소스 코드에 자체 작성된 함수 atoi(string, radix)와  itoa(number, radix)의 사용이다.

         let value = atoi(str, srcRdx)
         let str = itoa(value, destRdx)

지원되는 진법은 2진법에서 36진법까지이다.

1. (*
2.  *  Filename: ConvertRadix.fs
3.  *            Convert radix in an interactive mode.
4.  *
5.  *  Compile: fsc convertRadix.fs
6.  *  Execute: ConvertRadix
7.  *
8.  *      Date:  2010/07/14
9.  *    Author:  PH Kim   [ pkim (AT) scripts.pe.kr ]
10.  *)
12. #light
14. exception RuntimeError of string
15. exception ValueError of string
17. let println s =
18.     printfn "%O" s
20. let print s =
21.     printf "%O" s
23. let printUsage dummy =
24.     println "Usage: python convertRadix.py"
25.     println "Convert radix in a interactive mode, where the maximum radix is 36."
27. let printAbout dummy =
28.     println "    About: Convert radix in a interactive mode."
30. let printMainMenu dummy =
31.     println "  Command: (S)et radix, (A)bout, (Q)uit or E(x)it"
33. let printMainPrompt dummy =
34.     print "  Prompt> "
36. let printSubMenu srcRadix destRadix =
37.     println ("    Convert Radix_" + (sprintf "%O" srcRadix) + " to Radix_" + (sprintf "%O" DestRadix) )
38.     println ("    SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit" )
40. let printSubPrompt dummy =
41.     print "    Input Value>> "
43. let BASE36 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
45. let itoa (num : int, radix : int) =
46.    let mutable isNegative = false
47.    let mutable numx = num
48.    if num < 0 then
49.       isNegative <- true
50.       numx <- (-num)
52.    let mutable arr = [  ]
53.    let mutable q = numx
54.    let mutable r = 0
56.    while (q >= radix) do
57.        r <- int (q % radix)
58.        q <- int (q / radix)
59.        arr <- List.append arr [ sprintf "%O" (BASE36.[r]) ]
61.    arr <- List.append arr [ sprintf "%O" (BASE36.[q]) ]
62.    if isNegative then
63.       arr <- List.append arr [ "-" ]
65.    arr <- List.rev arr
66.    System.String.Join("", List.toArray arr)
68. let atoi (s : string, radix : int) : int =
69.     let mutable ret = 0
70.     let mutable isNegative = false
71.     let len = s.Length
72.     let mutable valx = 0
73.     let mutable c = s.[0]
75.     if c = '-' then
76.         isNegative <- true
77.     elif (c >= '0' && c <= '9') then
78.         ret <- (int c) - (int '0')
79.     elif (c >= 'A' && c <= 'Z') then
80.         ret <- int c - int 'A' + 10
81.     elif (c >= 'a' && c <= 'z') then
82.         ret <- int c - int 'a' + 10
83.     if (ret >= radix) then
84.         printfn "    Error: Can not read \"%s\" (as radix %d): %O is an invalid character!" s radix ret
86.     for i = 1 to len - 1 do
87.         c <- s.[i]
88.         ret <- ret*radix
89.         if (c >= '0' && c <= '9') then
90.             valx <- int c - int '0'
91.         elif (c >= 'A' && c <= 'Z') then
92.             valx <- int c - int 'A' + 10
93.         elif (c >= 'a' && c <= 'z') then
94.             valx <- int c - int 'a' + 10
95.         if (valx >= radix) then
96.             printfn "    Error: Can not read \"%s\" (as radix %d): %O is an invalid character!" s radix c
97.         ret <- ret + valx
99.     if (isNegative) then
100.         ret <- (-ret )
101.     ret
103. let convertRadix s srcRdx destRdx =
104.     let mutable ret = ""
105.     try
106.         try
107.             let valx = atoi (s, srcRdx)
108.             ret <- itoa (valx, destRdx)
109.             ret <- ret.ToUpper()
110.             ret
111.         with
112.             | ValueError e -> printfn "    Error: Cannot convert radix %O" srcRdx
113.                               ret <- "????"
114.                               ret
115.     finally
116.         ret.ToUpper() |> ignore
118. let doConvert srcRadix destRadix =
119.     let mutable line = ""
120.     let mutable cmd = ""
121.     let mutable srcStr = ""
122.     let mutable destStr = ""
123.     printfn ""
125.     printSubMenu srcRadix  destRadix
126.     let mutable stop_flag = false
127.     try
128.         while not stop_flag do
129.             printSubPrompt()
130.             let mutable cmd = System.Console.ReadLine()
131.             while (String.length cmd) = 0 do
132.                 cmd <- System.Console.ReadLine()
134.             if "main()" = cmd then
135.                 stop_flag <- false
136.                 raise (RuntimeError ("return to main menu"))
137.             elif "exit()" = cmd || "quit()" = cmd then
138.                 exit(0)
140.             try
141.                 let dum = atoi(cmd, srcRadix) |> ignore
142.                 srcStr <- cmd
143.                 destStr <- (convertRadix srcStr srcRadix destRadix)
144.                 printfn "        ( %s )_%d   --->   ( %s )_%d" srcStr srcRadix destStr destRadix
145.                 printfn ""
146.             with
147.                 | ValueError e -> println ""
148.     with
149.         | RuntimeError e -> printfn "      %O" e
151. let doStart dummy =
152.     let mutable line = ""
153.     let mutable cmd = ""
154.     let mutable srcRadix = 10
155.     let mutable destRadix = 10
156.     let mutable srcStr = ""
157.     let mutable destStr = ""
158.     let mutable onlyOnce = true
159.     let mutable st = [| |]
161.     try
162.         while true do
163.             printfn ""
164.             if onlyOnce then
165.                 println "  The supported maximum radix is 36."
166.                 onlyOnce <- false
168.             printMainMenu 0
169.             printMainPrompt 0
171.             cmd <- System.Console.ReadLine()
172.             while (String.length cmd) = 0 do
173.                 cmd <- System.Console.ReadLine()
175.             if "qQxX".IndexOf(cmd) >= 0 && (String.length cmd) = 1 then
176.                 exit(0)
177.             elif "aA".IndexOf(cmd) >= 0 && cmd.Length = 1 then
178.                 printAbout 0
179.             elif "sS".IndexOf(cmd) >= 0 && cmd.Length = 1 then
180.                 print "  Input the source and target radices (say, 16 2): "
181.                 line <- System.Console.ReadLine()
182.                 st <- line.Split [| ' ' |]
184.                 while (Array.length st) < 2 do
185.                     print ("  Input the source and target radices (say, 16 2): ")
186.                     line <- System.Console.ReadLine()
187.                     st <- line.Split [| ' ' |]
189.                 srcRadix <- int (st.[0])
190.                 destRadix <- int (st.[1])
191.                 doConvert srcRadix destRadix
192.     with
193.         | RuntimeError e ->  printfn "  Error foune!!"
195. // Begin here
196. let cmdArgs = System.Environment.GetCommandLineArgs()
197. if (Array.length cmdArgs > 1 && "-h" = cmdArgs.[1]) then
198.     printUsage 0
199.     exit(1)
201. doStart 0 |> ignore

다음은  이차방정식 x^2 - x - 1  = 0 의 양의 근 즉 황금비율(golden ratio)을 구하는 F# 소스이다. 황금비율을 구하는 비례방정식은   1 : x = x : (x+1) 이며, 이를 이차방정식으로 표현한 것이 x^2 - x - 1  = 0 이다.

See:  http://en.wikipedia.org/wiki/Golden_ratio

1. (*
2.  *  Filename: TestGoldenRatio.fs
3.  *    황금률(즉, 이차방정식 x^2 - x - 1  = 0 의 양의 근)을 계산한다.
4.  *
5.  *   Compile: fsc testGoldenRatio.fs
6.  *   Execute: testGoldenRatio
7.  *
8.  *      Date:  2010/07/13
9.  *    Author: PH Kim   [ pkim (AT) scripts.pe.kr ]
10.  *)
12. #light
14. exception RuntimeError of string
16. let printUsing =
17.     printfn "Using: TestGoldenRatio [-h|-help]"
18.     printfn "This calculates the value of the golden ratio."
20. // 이차방정식 a x^2 + b x + c  = 0 의 근을 구한다.
21. let findQuadraticRoot (a : float,  b : float, c : float) =
22.     if a = 0.0 then
23.         raise (RuntimeError "Since the highest coefficient is zero, the given equation is not a quadratic equation.")
24.     elif (b*b - 4.0*a*c < 0.0) then
25.         raise (RuntimeError ("Since the discriminant " + (sprintf "%O" (b*b - 4.0*a*c)) + " is negative, the given equation has no real root."))
27.     let x1 = (-b + (sqrt (b*b - 4.0*a*c))) / (2.0 * a)
28.     let x2 = (-b - (sqrt (b*b - 4.0*a*c))) / (2.0 * a)
29.     x1, x2
31. // 실행 시작 지점
32. let cmdArgs = System.Environment.GetCommandLineArgs()
33. if (Array.length cmdArgs > 1) && (cmdArgs.[1] = "-h" || cmdArgs.[1] = "-help") then
34.     printUsing; exit(1)
36. let x1, x2 = findQuadraticRoot (1.0 , -1.0 , -1.0)
37. if x1 >= x2 then
38.     printfn "The bigger root is %O, " x1
39.     printfn "and the less root is %O." x2
40. else
41.     printfn "The bigger root is %O, " x2
42.     printfn "and the less root is %O." x1

컴파일> fsc TestGoldenRatio.fs

실행>TestGoldenRatio
The bigger root is 1.61803398874989,
and the less root is -0.618033988749895.

1. (*
2.  *  Filename: TestCTimeApp.fs
3.  *
4.  *  Compile: fsc --codepage:949 TestCTimeApp.fs
5.  * 
6.  *  Execute: TestCTimeApp 
7.  *)
9. // namespace MyTestApp1
11. open System
13. let weekNames = [| "일"; "월"; "화"; "수"; "목"; "금"; "토" |]
15. let now = System.DateTime.Now
16. let startOfEpoch = new DateTime ( 1970, 1, 1 )
18. // 1970년 1월 1일 0시 0분 0초부터 시작하여 현재까지의 초
19. printfn "UTC: %O" ((int64 (DateTime.UtcNow - startOfEpoch).TotalMilliseconds) / 1000L)
20. // 현재 시각 표시: 20xx년 xx월 xx일 (x요일) xx시 xx분 xx초
21. printf "%O년 " (now.Year)
22. printf "%O월 " (now.Month)     // Not 1 + now.Month !!
23. printf "%O일 " (now.Day)
24. printf "(%O요일) " (weekNames.[int (now.DayOfWeek)])
25. printf "%O시 " (now.Hour)
26. printf "%O분 " (now.Minute)
27. printfn "%O초" (now.Second)
29. // 1월 1일은 1, 1월 2일은 2
30. printf "올해 몇 번째 날: %O, " (now.DayOfYear)
32. // True 이면 서머타임 있음
33. let str = if not (now.IsDaylightSavingTime()) then "안함" else "함"
34. printfn "서머타임 적용 여부: %O"  str

컴파일> fsc TestCTimeApp.fs

실행> TestCTimeApp
UTC: 1279016975
2010년 7월 13일 (화요일) 19시 29분 35초
올해 몇 번째 날: 194, 서머타임 적용 여부: 안함

Python용 소스파일 testForFor.py를 F# 용으로 수정한 것이다.
F#의 if 구문과 for 구문이 Python의 것과 (들여쓰기하는 것 까지) 많이 닮았다.
F#은 함수형 언어기도 하고 명령형 언어이기도 하므로, 여기서는 가급적 F#의 명령형 언어의 특징을 위주로 작성하였다.

1. (* 
2.  *  Filename: TestForFor.fs
3.  *
4.  *  Compile:  fsc TestForFor.fs
5.  *  Execute:  TestForFor
6.  *
7.  *  Date:  2010. 7. 13
8.  *)
10. # light
12. let getDan dan =
13.     let t = [| for i in 1..19 -> "" |]
14.     for j in 0..(19 - 1) do
15.         let mutable sa = sprintf "%d" dan
16.         if (String.length sa) < 2 then
17.             sa <- sprintf " %d" dan
18.         let mutable sb = sprintf "%d" (j + 1)
19.         if (String.length sb) < 2 then
20.             sb <- sprintf " %d" (j + 1)
21.         let mutable sval = sprintf "%d" (dan*(j + 1))
22.         if (String.length sval) < 2 then
23.             sval <- sprintf "  %d" (dan*(j + 1))
24.         elif (String.length sval) < 3 then
25.             sval <- sprintf " %d" (dan*(j + 1))
26.         t.[j] <- sa + " x " + sb + " = " + sval
27.     t
29. // 19단표를 모두 80컬럼 컨솔에 출력한다.
30. let printAllNineteenDan =
31.     let arr = [| for u in 1..19 -> [| for j in 1..18 -> "" |] |]
32.     for i in 2..(20 - 1) do
33.         arr.[i - 2] <- (getDan i )
35.     // F# 소스 코드에서는 리스트 대신 배열을 사용한다.
36.     let d = [| 2; 7; 11; 16 |]      // 각 줄단위 블럭의 첫단
37.     let counter = [| 5; 4; 5; 4 |]  // 각 줄단위 블럭에 속한 단의 개수
38.     let lines = [| for u in 1..19 -> "" |]
40.     for k in 0..((Array.length d) - 1) do
41.         // 8-바이트 길이의 한 줄씩 완성
42.         for i in 0..(19 - 1) do
43.             lines.[i] <- (arr.[d.[k]-2].[i])
44.             for j in 1..(counter.[k] - 1) do
45.                 lines.[i] <- ((lines.[i]) + "   " +  (arr.[d.[k]-2+j].[i]))
47.         // 80 바이트 길이의 한 줄씩 출력
48.         for i in 0..(19 - 1) do
49.             printfn "%s" (lines.[i])
50.         printfn ""
52. printAllNineteenDan

컴파일: 
Prompt> fsc TestForFor.fㄴ 

실행: 
Prompt> TestForFor 
2 x  1 =   2    3 x  1 =   3    4 x  1 =   4    5 x  1 =   5    6 x  1 =   6
2 x  2 =   4    3 x  2 =   6    4 x  2 =   8    5 x  2 =  10    6 x  2 =  12
2 x  3 =   6    3 x  3 =   9    4 x  3 =  12    5 x  3 =  15    6 x  3 =  18
2 x  4 =   8    3 x  4 =  12    4 x  4 =  16    5 x  4 =  20    6 x  4 =  24
2 x  5 =  10    3 x  5 =  15    4 x  5 =  20    5 x  5 =  25    6 x  5 =  30
2 x  6 =  12    3 x  6 =  18    4 x  6 =  24    5 x  6 =  30    6 x  6 =  36
2 x  7 =  14    3 x  7 =  21    4 x  7 =  28    5 x  7 =  35    6 x  7 =  42
2 x  8 =  16    3 x  8 =  24    4 x  8 =  32    5 x  8 =  40    6 x  8 =  48
2 x  9 =  18    3 x  9 =  27    4 x  9 =  36    5 x  9 =  45    6 x  9 =  54
2 x 10 =  20    3 x 10 =  30    4 x 10 =  40    5 x 10 =  50    6 x 10 =  60
2 x 11 =  22    3 x 11 =  33    4 x 11 =  44    5 x 11 =  55    6 x 11 =  66
2 x 12 =  24    3 x 12 =  36    4 x 12 =  48    5 x 12 =  60    6 x 12 =  72
2 x 13 =  26    3 x 13 =  39    4 x 13 =  52    5 x 13 =  65    6 x 13 =  78
2 x 14 =  28    3 x 14 =  42    4 x 14 =  56    5 x 14 =  70    6 x 14 =  84
2 x 15 =  30    3 x 15 =  45    4 x 15 =  60    5 x 15 =  75    6 x 15 =  90
2 x 16 =  32    3 x 16 =  48    4 x 16 =  64    5 x 16 =  80    6 x 16 =  96
2 x 17 =  34    3 x 17 =  51    4 x 17 =  68    5 x 17 =  85    6 x 17 = 102
2 x 18 =  36    3 x 18 =  54    4 x 18 =  72    5 x 18 =  90    6 x 18 = 108
2 x 19 =  38    3 x 19 =  57    4 x 19 =  76    5 x 19 =  95    6 x 19 = 114

7 x  1 =   7    8 x  1 =   8    9 x  1 =   9   10 x  1 =  10
7 x  2 =  14    8 x  2 =  16    9 x  2 =  18   10 x  2 =  20
7 x  3 =  21    8 x  3 =  24    9 x  3 =  27   10 x  3 =  30
7 x  4 =  28    8 x  4 =  32    9 x  4 =  36   10 x  4 =  40
7 x  5 =  35    8 x  5 =  40    9 x  5 =  45   10 x  5 =  50
7 x  6 =  42    8 x  6 =  48    9 x  6 =  54   10 x  6 =  60
7 x  7 =  49    8 x  7 =  56    9 x  7 =  63   10 x  7 =  70
7 x  8 =  56    8 x  8 =  64    9 x  8 =  72   10 x  8 =  80
7 x  9 =  63    8 x  9 =  72    9 x  9 =  81   10 x  9 =  90
7 x 10 =  70    8 x 10 =  80    9 x 10 =  90   10 x 10 = 100
7 x 11 =  77    8 x 11 =  88    9 x 11 =  99   10 x 11 = 110
7 x 12 =  84    8 x 12 =  96    9 x 12 = 108   10 x 12 = 120
7 x 13 =  91    8 x 13 = 104    9 x 13 = 117   10 x 13 = 130
7 x 14 =  98    8 x 14 = 112    9 x 14 = 126   10 x 14 = 140
7 x 15 = 105    8 x 15 = 120    9 x 15 = 135   10 x 15 = 150
7 x 16 = 112    8 x 16 = 128    9 x 16 = 144   10 x 16 = 160
7 x 17 = 119    8 x 17 = 136    9 x 17 = 153   10 x 17 = 170
7 x 18 = 126    8 x 18 = 144    9 x 18 = 162   10 x 18 = 180
7 x 19 = 133    8 x 19 = 152    9 x 19 = 171   10 x 19 = 190

11 x  1 =  11   12 x  1 =  12   13 x  1 =  13   14 x  1 =  14   15 x  1 =  15
11 x  2 =  22   12 x  2 =  24   13 x  2 =  26   14 x  2 =  28   15 x  2 =  30
11 x  3 =  33   12 x  3 =  36   13 x  3 =  39   14 x  3 =  42   15 x  3 =  45
11 x  4 =  44   12 x  4 =  48   13 x  4 =  52   14 x  4 =  56   15 x  4 =  60
11 x  5 =  55   12 x  5 =  60   13 x  5 =  65   14 x  5 =  70   15 x  5 =  75
11 x  6 =  66   12 x  6 =  72   13 x  6 =  78   14 x  6 =  84   15 x  6 =  90
11 x  7 =  77   12 x  7 =  84   13 x  7 =  91   14 x  7 =  98   15 x  7 = 105
11 x  8 =  88   12 x  8 =  96   13 x  8 = 104   14 x  8 = 112   15 x  8 = 120
11 x  9 =  99   12 x  9 = 108   13 x  9 = 117   14 x  9 = 126   15 x  9 = 135
11 x 10 = 110   12 x 10 = 120   13 x 10 = 130   14 x 10 = 140   15 x 10 = 150
11 x 11 = 121   12 x 11 = 132   13 x 11 = 143   14 x 11 = 154   15 x 11 = 165
11 x 12 = 132   12 x 12 = 144   13 x 12 = 156   14 x 12 = 168   15 x 12 = 180
11 x 13 = 143   12 x 13 = 156   13 x 13 = 169   14 x 13 = 182   15 x 13 = 195
11 x 14 = 154   12 x 14 = 168   13 x 14 = 182   14 x 14 = 196   15 x 14 = 210
11 x 15 = 165   12 x 15 = 180   13 x 15 = 195   14 x 15 = 210   15 x 15 = 225
11 x 16 = 176   12 x 16 = 192   13 x 16 = 208   14 x 16 = 224   15 x 16 = 240
11 x 17 = 187   12 x 17 = 204   13 x 17 = 221   14 x 17 = 238   15 x 17 = 255
11 x 18 = 198   12 x 18 = 216   13 x 18 = 234   14 x 18 = 252   15 x 18 = 270
11 x 19 = 209   12 x 19 = 228   13 x 19 = 247   14 x 19 = 266   15 x 19 = 285

16 x  1 =  16   17 x  1 =  17   18 x  1 =  18   19 x  1 =  19
16 x  2 =  32   17 x  2 =  34   18 x  2 =  36   19 x  2 =  38
16 x  3 =  48   17 x  3 =  51   18 x  3 =  54   19 x  3 =  57
16 x  4 =  64   17 x  4 =  68   18 x  4 =  72   19 x  4 =  76
16 x  5 =  80   17 x  5 =  85   18 x  5 =  90   19 x  5 =  95
16 x  6 =  96   17 x  6 = 102   18 x  6 = 108   19 x  6 = 114
16 x  7 = 112   17 x  7 = 119   18 x  7 = 126   19 x  7 = 133
16 x  8 = 128   17 x  8 = 136   18 x  8 = 144   19 x  8 = 152
16 x  9 = 144   17 x  9 = 153   18 x  9 = 162   19 x  9 = 171
16 x 10 = 160   17 x 10 = 170   18 x 10 = 180   19 x 10 = 190
16 x 11 = 176   17 x 11 = 187   18 x 11 = 198   19 x 11 = 209
16 x 12 = 192   17 x 12 = 204   18 x 12 = 216   19 x 12 = 228
16 x 13 = 208   17 x 13 = 221   18 x 13 = 234   19 x 13 = 247
16 x 14 = 224   17 x 14 = 238   18 x 14 = 252   19 x 14 = 266
16 x 15 = 240   17 x 15 = 255   18 x 15 = 270   19 x 15 = 285
16 x 16 = 256   17 x 16 = 272   18 x 16 = 288   19 x 16 = 304
16 x 17 = 272   17 x 17 = 289   18 x 17 = 306   19 x 17 = 323
16 x 18 = 288   17 x 18 = 306   18 x 18 = 324   19 x 18 = 342
16 x 19 = 304   17 x 19 = 323   18 x 19 = 342   19 x 19 = 361

소스 파일명: TestNoWhile.fs

1. (*
2.  *  Filename: TestNoWhile.fs
3.  *
4.  *  Purpose:  Example using the while loop syntax
5.  *                while ....
6.  *
7.  *  Compile: fsc --codepage:949 TestNoWhile.fs
8.  *  Execute: TestNoWhile -200 300
9.  *)
11. #light
13. // 사용법 표시
14. let printUsage x =
15.     printfn "Using: TestNoWhile [integer1] [integer2]"
16.     printfn "This finds the greatest common divisor of the given two integers."
18. let cmdArgs = System.Environment.GetCommandLineArgs()
19. if not ((Array.length cmdArgs) = 3) then
20.     printUsage 0
21.     exit(1)
23. // --------------------------------------
24. // 명령행 인자의 두 스트링을 가져와서
25. // 정수 타입으로 변환하여
26. // 변수 val1과 val2에 저장한다.
27. let val1 = int cmdArgs.[1]
28. let val2 = int cmdArgs.[2]
30. // a는 |val1|, |val2| 중 큰 값
31. let mutable a = abs val1
32. let mutable b = abs val2
34. let max x y = if y > x then y else x
35. let min x y = if y > x then x else y
37. let maxab = max a b
38. let minab = min a b
39. a <- maxab
40. b <- minab
42. // --------------------------------------
43. // 재귀호출 Euclidean 알고리즘
44. //
45. //     Euclidean 알고리즘의 반복 (나머지가 0이 될 때 까지)
46. //     나머지가 0이면 그 때 나눈 수(제수) x가 최대공약수(GCD)이다.
47. let rec gcdRecursive x y =
48.     match y with
49.     | 0 -> x
50.     | _ -> gcdRecursive y (x % y)
52. let gcd = gcdRecursive a b
54. // 최대공약수(GCD)를 출력한다.
55. printfn "GCD(%d, %d) = %d" val1 val2 gcd

컴파일:

Command> fsc TestNoWhile.fs

실행:

Command> TestNoWhile
Using: TestNoWhile [integer1] [integer2]
This finds the greatest common divisor of the given two integers.

Command> TestNoWhile -200 300
GCD(-200, 300) = 100

Command> TestNoWhile -200 0
GCD(-200, 0) = 200

Command> TestNoWhile 125 100
GCD(125, 100) = 25

Command> TestNoWhile 23 25
GCD(23, 25) = 1

소스 파일명: TestWhile.fs

1. (*
2.  *  Filename: TestWhile.fs
3.  *
4.  *  Purpose:  Example using the while loop syntax
5.  *                while ....
6.  * 
7.  *  Compile: fsc --codepage:949 TestWhile.fs
8.  *  Execute: TestWhile -200 300
9.  *)
11. #light
13. // 사용법 표시
14. let printUsage x =
15.     printfn "Using: TestWhile.py [integer1] [integer2]"
16.     printfn "This finds the greatest common divisor of the given two integers."
18. let cmdArgs = System.Environment.GetCommandLineArgs()
19. if not ((Array.length cmdArgs) = 3) then
20.     printUsage 0
21.     exit(1)
23. // --------------------------------------
24. // 명령행 인자의 두 스트링을 가져와서
25. // 정수 타입으로 변환하여
26. // 변수 val1과 val2에 저장한다.
27. let val1 = int cmdArgs.[1]
28. let val2 = int cmdArgs.[2]
30. // a는 |val1|, |val2| 중 큰 값
31. let mutable a = abs val1
32. let mutable b = abs val2
34. if a < b then
35.     a <- abs val2
36.     b <- abs val1
38. if b = 0 then
39.     printfn "GCD(%d, %d) = %d" val1 val2 a
40.     exit(0)
42. // --------------------------------------
43. // Euclidean 알고리즘의 시작
44. //
45. // a를 b로 나누어 몫은 q에, 나머지는 r에 저장
46. let mutable q = a / b
47. let mutable r = a % b
49. // --------------------------------------
50. // Euclidean 알고리즘의 반복 (나머지 r이 0이 될 때 까지)
51. while not (r = 0) do
52.     a <- b
53.     b <- r
54.     q <- a / b
55.     r <- a % b
57. // 나머지가 0이면 그 때 나눈 수(제수) b가 최대공약수(GCD)이다.
58. let gcd = b
60. // 최대공약수(GCD)를 출력한다.
61. printfn "GCD(%d, %d) = %d" val1 val2 gcd

컴파일:

Command> fsc TestWhile.fs

실행:

Command> TestWhile
Using: TestWhile [integer1] [integer2]
This finds the greatest common divisor of the given two integers.

Command> TestWhile -200 300
GCD(-200, 300) = 100

Command> TestWhile -200 0
GCD(-200, 0) = 200

Command> TestWhile 125 100
GCD(125, 100) = 25

Command> TestWhile 23 25
GCD(23, 25) = 1

F# 언어는 함수형 언어이면서도 명령형 언어의 특징을 대부분 가지고 잇다.
따라서 보통의 for 구문을 쓸 수도 있고, 재귀호출 함수릉 만들어 쓸 수도 있다.

아래의 소스에서 함수 printDan 은 보통의 for 구문을 쓴 것이고
함수 printAnotherDan 은 재귀호출 함수를 쓴 것이다.


소스 파일명: forTest.fs
------------------------------[소스 시작]
let printDan dan =
    for i in 1..9 do
        printfn "%d x %d = %d" dan i (dan*i)

let printAnotherDan (dan : int) =
    let rec loop l =
        match l with
        | x :: xs -> printfn "%d x %d = %d" dan x (dan*x); loop xs
        | [] -> None
    loop [1..9]

printDan 2
printAnotherDan 3 |> ignore
------------------------------[소스 끝]


컴파일> fsc forTest.fs

실행> forTest2 x 1 = 2
2 x 2 = 4
2 x 3 = 6
2 x 4 = 8
2 x 5 = 10
2 x 6 = 12
2 x 7 = 14
2 x 8 = 16
2 x 9 = 18
3 x 1 = 3
3 x 2 = 6
3 x 3 = 9
3 x 4 = 12
3 x 5 = 15
3 x 6 = 18
3 x 7 = 21
3 x 8 = 24
3 x 9 = 27

Python 언어에서 명령행 인자는 sys.argv 라는 변수로 처리한다.
sys.argv는 모듈 sys에 속하는 변수 argv를 의미하며, 이는 명령행 실행시 옵션으로 입력된 인자들을 스트링 값으로 모아둔 리스트형의 변수이다.
모듈 sys을 하기 위해서는

        import sys

라는 수입(import) 구문을 소스 선두 부분에 적어주어야 한다.

C/C++/Java/Ruby 언어들과는 달리 리스트의 0번의 값(즉 sys.argv[0])은 python 명령 바로 다음에 입력된 (실행될) Python 소스파일명을 가리키므로, 1번부터 처리해야 한다. 즉 Python 언어에서 sys.argv[1], sys.argv[2], sys.argv[3], ... 들이 각각 C 언어의 argv[0], argv[1], argv[2], .... 들에 해당하며, Java 언어의 args[0], args[1], args[2], ... 들에 해당한다.

다음 소스의 앞 부분에

    #! /usr/bin/python
    # -*- encoding: euc-kr -*-

를 적어둔 것은 소스 코드에서 (주석문에) ASCII 가 아닌 문자(여기서는 한글 euc-kr)를 소스 코드에서 사용하고 있기 때문이다. 이 두 줄은

    #! /usr/bin/python
    # coding: euc-kr

으로 하여도 된다. 만일 소스 코드 파일을 utf-8 인코딩으로 저장하였다면 euc-kr 대신 utf-8로 하여야 할 것이다. (참고로, Ubuntu 플랫폼에서는 소스파일 저장시 반드시 utf-8 인코딩으로 저장하여야 한다.)


소스파일명: testArguments.fs

1. // Filename: testArguments.fs
3. let main =
4.     let cmdArgs = System.Environment.GetCommandLineArgs()
5.     let args = cmdArgs.[1..]
6.     let arr : float list = [ for i in args -> double i]
7.     printfn "Count of arguments: %O" (List.length arr)
8.     printfn "The sum of arguments is %O" (List.sum arr)

컴파일> fsc testArguments.fs

실행> testArguments 1 2 3 4
Count of arguments: 4
The sum of arguments is 10

소스 파일명: TestIf.fs

1. // Filename: TestIf.fs
3. #light
5. let printUsing x =
6.      printfn "Using: TestIf [number]"
7.      printfn "This determines whether the number is positive or not."
9. let (|Float|_|) (str: string) =
10.    let mutable floatvalue = 0.0
11.    if System.Double.TryParse(str, &floatvalue) then Some(floatvalue)
12.    else None
14. let isPositveNegative = function
15.      | x when x > 0.0 -> "positive"
16.      | x when x < 0.0 -> "negative"
17.      | x when x = 0.0 -> "zero"
18.      | _ -> "not a floating number"
20. let doCheck s =
21.     match s with
22.     | Float s ->
23.         let mutable y = 1.0
24.         y <- System.Convert.ToDouble(s)
25.         printfn "%g is %O." y (isPositveNegative y)
26.     | _ -> printUsing 0
28. let cmdArgs = System.Environment.GetCommandLineArgs()
30. if (Array.length cmdArgs > 1) then
31.     doCheck (cmdArgs.[1])
32. else printUsing 0

컴파일> fsc TestIf.fs

실행> TestIf -1.2
-1.2 is negative.

실행> TestIf 0.0
-1.2 is zero.





이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이센스에 따라 이용하실 수 있습니다.