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

[파일명:  TestStringFindInList.fs]------------------------------------------------
#light

let find arr s = List.findIndex (fun x -> x = s) arr

let printList data =
    let rec loop l =
        match l with
        | x::[] -> printf "%O" x
        | x::xs -> printf "%O, " x; loop xs
        | [] -> printf ""
    printf "["
    loop data
    printf "]"

// Begin here
let cmdArgs = System.Environment.GetCommandLineArgs()

let words = ["하나"; "둘"; "셋"; "넷"; "다섯"; "여섯"]

printf "list: "
printList words
printfn ""
let where1 = find words "셋"
if where1 >= 0 then
    printf "발견!  "
    printf "Next word of 셋 in list: %O" (words.[where1+1])
printfn ""

printfn "Sorting..."
let otherwords = words |> List.sort |> List.sort

printf "list: "
printList otherwords
printfn ""
let where2 = find otherwords "셋"
if where2 >= 0 then
    printf "발견!  "
    printf "Next word of 셋 in list: %O" (otherwords.[where2+1])
printfn ""
------------------------------------------------


컴파일> fsc --codepage:949 TestStringFindInList.fs

실행> TestStringFindInList
list: [하나, 둘, 셋, 넷, 다섯, 여섯]
발견!  Next word of 셋 in list: 넷
Sorting...
list: [넷, 다섯, 둘, 셋, 여섯, 하나]
발견!  Next word of 셋 in list: 여섯

printList 함수를 F#의 함수형 언어의 특징을 살려 (꼬리 재귀호출과 match 표현을 이용하여) 구현하였다.

[파일명:  TestSort.fs]------------------------------------------------
#light

let printList data =
    let rec loop l =
        match l with
        | x::[] -> printf "%O" x
        | x::xs -> printf "%O, " x; loop xs
        | [] -> printf ""
    printf "["
    loop data
    printf "]"

// Begin here
let cmdArgs = System.Environment.GetCommandLineArgs()
let b = cmdArgs.[1..] |> Array.toList |> List.sort
printList b
------------------------------------------------


컴파일> fsc TestSort.fs

실행> TestSort one two three four five
[five, four, one, three, two]

실행> TestSort 하나 둘 셋 넷 다섯
[넷, 다섯, 둘, 셋, 하나]

초등학교 때 배우던 두 정수의 곱셈표를 만들어 주는 F# 소스이다.
이 소스는 Python 소스를 F# 소스로 변환한 것이라 F#의 명령형 언어 특징을 위주로 짜여져 있다.

컴파일> fsc MakeMultTable.fs

실행> MakeMultTable 230 5100
결과>

         230
   x )   5100
     ------
         23
       115
     ------
       1173000

다음은 초등학교에서 배우는 나눗셈 계산표를 만들어주는 F# 소스 코드이다.
나눗셈 계산표를 완성하고 나서 약수, 배수 관계를 알려준다.

아래의 소스는 Python 용 소스를 F# 용 소스로 거의 일대일 변환한 것이라서, F# 언어의 명령형 언어의 특징을 위주로 짜여져 있다.

1. (*
2.  *  Filename: MakeDivisionTable.fs
3.  *
4.  *  Purpose:  Make a division table in a handy written form.
5.  *
6.  *  Compile: fsc --codepage:949 MakeDivisionTable.fs
7.  *
8.  *  Execute: MakeDivisionTable 12345 32
9.  *           MakeDivisionTable 500210 61
10.  *           MakeDivisionTable 234 55
11.  *
12.  *     Date:  2010/07/15
13.  *   Author:  PH Kim   [ pkim ((AT)) scripts.pe.kr ]
14.  *)
16. #light
18. exception RuntimeError of string
19. exception ValueError of string
21. let BASE36 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
22. let SPACE = "                                                          "
23. let ULINE = "__________________________________________________________"
24. let HIPHEN = "----------------------------------------------------------"
26. let println s =
27.     printfn "%O" s
29. let print s =
30.     printf "%O" s
32. let printUsage dummy =
33.     // print("Using: MakeDivisionTable [numerator] [denominator]")
34.     // print("Make a division table in a handy written form.")
35.     println "사용법: MakeDivisionTable [피제수] [제수]"
36.     println "손으로 작성한 형태의 나눗셈 표를 만들어준다."
38. let simplify v width =
        let mutable t = sprintf "%d" v
39.     if (t.EndsWith ".0") then
40.         t <- t.Substring(0, t.Length - 2)
41.     let slen = t.Length
42.     if slen < width then
43.         t <- SPACE.Substring(0, width - slen) + t
44.     t
46. let getSuffix v =
47.     let mutable t = v % 10
48.     let mutable suffix = "은"
49.     if "2459".IndexOf(sprintf "%d"  t) >= 0 then
50.         suffix <- "는"
51.     suffix
53. let makeTable numer denom quotient =
54.     let strNumer = sprintf "%d" numer
55.     let strDenom = sprintf "%d" denom
56.     let strQuotient = sprintf "%d" quotient
57.     let lenN = strNumer.Length
58.     let lenD = strDenom.Length
59.     let lenQ = strQuotient.Length
60.     let offsetLeft = 3 + lenD + 3
61.     let spaces = "                                                                                 "
62.     let mutable uline  = ULINE.Substring(0, lenN + 2)
63.     let mutable sline  = HIPHEN.Substring(0, lenN)
64.     let bias = lenN - lenQ
66.     println(spaces.Substring(0, offsetLeft) + spaces.Substring(0, bias) + sprintf "%d" quotient)
67.     println(spaces.Substring(0, offsetLeft - 2) + uline)
68.     print("   " + strDenom + " ) " + strNumer)
70.     let mutable strTmpR = strNumer.Substring(0, bias + 1)
71.     let mutable tmpR = int strTmpR
72.     let mutable tmpSub = 0
73.     let mutable oneDigit = ""
75.     for i in 0..(lenQ - 1) do
76.         if (strQuotient.Substring(i, 1)) = "0" then
77.             if i + 1 < lenQ then
78.                 oneDigit <- (strNumer.Substring(bias + i + 1, 1))
79.                 print(oneDigit)
80.                 strTmpR <- strTmpR + oneDigit
81.                 tmpR <- int strTmpR
82.         else
83.             println ""
84.             tmpSub <- (int (strQuotient.Substring(i, 1))) * denom
85.             println(spaces.Substring(0, offsetLeft) + simplify tmpSub  (bias + i + 1))
86.             println(spaces.Substring(0, offsetLeft) + sline)
87.             tmpR <- tmpR - tmpSub
89.             if tmpR = 0 && i + 1 < lenQ then
90.                 print(spaces.Substring(0, offsetLeft) + spaces.Substring(0, bias + i + 1))
91.             else 
92.                 print(spaces.Substring(0, offsetLeft) + (simplify tmpR (bias + i + 1))) 
94.             strTmpR <- sprintf "%d" tmpR
95.             if i + 1 < lenQ then
96.                 oneDigit <- (strNumer.Substring(bias + i + 1, 1))
97.                 if  (oneDigit.Length) > 0 then
98.                     print(oneDigit)
99.                 strTmpR <- strTmpR + oneDigit
100.             tmpR <- int strTmpR
102.     println ""
103.     tmpR
106. // Begin here
107. let cmdArgs = System.Environment.GetCommandLineArgs()
108. if (Array.length cmdArgs < 3 || "-h" = cmdArgs.[1]) then
109.     printUsage 0
110.     exit(1)
112. let mutable a = 0
113. let mutable b = 1
115. try
116.     a <- int (cmdArgs.[1])
117.     b <- int (cmdArgs.[2])
118. with
119.     | ValueError e -> printfn "피제수: %s, 제수: %s" (cmdArgs.[1]) (cmdArgs.[2]);
120.                       printfn "숫자 입력에 오류가 있습니다.";
121.                       exit(1)
123. if a <= 0 then
124.     printf "피제수: %d" a
125.     printf "피제수는 양의 정수라야 합니다."
126.     exit(1)
127. elif b <= 0 then
128.     printf "제수: %d" b
129.     printf "제수는 양의 정수라야 합니다."
130.     exit(1)
132. let q = a / b
133. let r = a % b
135. printf "나눗셈 %d ÷ %d 의 결과: " a b
136. printf "몫: %d, " q
137. printfn "나머지: %d" r
138. printfn ""
140. let k = makeTable a b q
142. if k = r then
143.     printfn "\n나머지: %d" k
145. if k = 0 then
146.     printfn "%d = %d x %d" a b q
147.     printfn "%d%s %d의 배수(mupltiple)이다." a (getSuffix a) b
148.     printfn "%d%s %d의 약수(divisor)이다." b (getSuffix b) a
149. else
150.     printfn "%d = %d x %d + %d" a b q r
151.     printfn "%d%s %d의 배수(mupltiple)가 아니다." a (getSuffix a) b

컴파일> fsc --codepage:949   MakeDivisionTable.fs

실행> MakeDivisionTable.py 500210 61
나눗셈 500210 ÷ 61 의 결과: 몫: 8200, 나머지: 10

          8200
      ________
   61 ) 500210
         488
        ------
         122
         122
        ------
            10

나머지: 10
500210 = 61 x 8200 + 10
500210은 61의 배수(mupltiple)가 아니다.

ASCII(애스키)란 American Standard Code for Information Interchange의 줄임글로서, 영문자에 기초한 문자 인코딩이다.  이 문자 인코딩에는 C0 제어문자(C0 control character)도 포함되어 있다.  ( 참고:  ASCII - Wikipedia, the free encyclopedia )

다음은  7bit ASCII 코드표를 만들어 보여주는 F# 소스 코드이다. 소스 코드 중에 진법변환에 필요한 함수

                atoi(string, radix)
                itoa(number, radix)

를 F# 코드로 자체 작성하여 사용하였다.

(아래의 소스는 Python 소스를 F# 소스로 일대일 변환 수정한 것이라서, F# 언어의 명령형 언어 특징을 위주로 작성되어 있다.)

1. (*
2.  *  Filename: MakeAsciiTable.fs
3.  *            Make a table of ascii codes.
4.  *
5.  *  Compile: fsc MakeAsciiTable.fs
6.  *  Execute: MakeAsciiTable
7.  *
8.  *      Date:  20010/07/15
9.  *    Author:  PH Kim   [ pkim (AT) scripts.pe.kr ]
10.  *)
12. #light
14. exception RuntimeError of string
15. exception ValueError of string
17. let BASE36 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
19. let println s =
20.     printfn "%O" s
22. let print s =
23.     printf "%O" s
25. let printUsage dummy =
26.     println "Usage: MakeAsciiTable"
27.     println "Make a table of ascii codes."
29. let itoa (num : int, radix : int) =
30.    let mutable isNegative = false
31.    let mutable numx = num
32.    if num < 0 then
33.       isNegative <- true
34.       numx <- (-num)
36.    let mutable arr = [  ]
37.    let mutable q = numx
38.    let mutable r = 0
40.    while (q >= radix) do
41.        r <- int (q % radix)
42.        q <- int (q / radix)
43.        arr <- List.append arr [ sprintf "%O" (BASE36.[r]) ]
44.    arr <- List.append arr [ sprintf "%O" (BASE36.[q]) ]
46.    if isNegative then
47.       arr <- List.append arr [ "-" ]
49.    arr <- List.rev arr
50.    System.String.Join("", List.toArray arr)
53. let atoi (s : string, radix : int) : int =
54.     let mutable ret = 0
55.     let mutable isNegative = false
56.     let len = s.Length
57.     let mutable valx = 0
58.     let mutable c = s.[0]
60.     if c = '-' then
61.         isNegative <- true
62.     elif (c >= '0' && c <= '9') then
63.         ret <- (int c) - (int '0')
64.     elif (c >= 'A' && c <= 'Z') then
65.         ret <- int c - int 'A' + 10
66.     elif (c >= 'a' && c <= 'z') then
67.         ret <- int c - int 'a' + 10
69.     if (ret >= radix) then
70.         printfn "    Error: Can not read \"%s\" (as radix %d): %O is an invalid character!" s radix ret
72.     for i = 1 to len - 1 do
73.         c <- s.[i]
74.         ret <- ret*radix
75.         if (c >= '0' && c <= '9') then
76.             valx <- int c - int '0'
77.         elif (c >= 'A' && c <= 'Z') then
78.             valx <- int c - int 'A' + 10
79.         elif (c >= 'a' && c <= 'z') then
80.             valx <- int c - int 'a' + 10
82.         if (valx >= radix) then
83.             printfn "    Error: Can not read \"%s\" (as radix %d): %O is an invalid character!" s radix c
84. 
            ret <- ret + valx
86.     if (isNegative) then
87.         ret <- (-ret )
89.     ret
92. let asc = [
93.     "NUL"; "SOH"; "STX"; "ETX"; "EOT";
94.     "ENQ"; "ACK"; "BEL"; "BS"; "HT";
95.     "LF"; "VT"; "FF"; "CR"; "SO";
96.     "SI"; "DLE"; "DC1"; "DC2"; "DC3";
97.     "DC4"; "NAK"; "SYN"; "ETB"; "CAN";
98.     "EM"; "SUB"; "ESC"; "FS"; "GS";
99.     "RS"; "US"; "Spc"
100. ]
102. let control = [
103.     "NUL (null)";
104.     "SOH (start of heading)";
105.     "STX (start of text)";
106.     "ETX (end of text)";
107.     "EOT (end of transmission)";
108.     "ENQ (enquiry)";
109.     "ACK (acknowledge)";
110.     "BEL (bell)";
111.     "BS  (backspace)";
112.     "TAB (horizontal tab)";
113.     "LF  (line feed, NL new line)";
114.     "VT  (vertical tab)";
115.     "FF  (form feed, NP new page)";
116.     "CR  (carriage return)";
117.     "SO  (shift out)";
118.     "SI  (shift in)";
119.     "DLE (data link escape)";
120.     "DC1 (device control 1)";
121.     "DC2 (device control 2)";
122.     "DC3 (device control 3)";
123.     "DC4 (device control 4)";
124.     "NAK (negative acknowledge)";
125.     "SYN (synchronous idle)";
126.     "ETB (end of trans. block)";
127.     "CAN (cancel)";
128.     "EM  (end of medium)";
129.     "SUB (substitute, EOF end of file)";
130.     "ESC (escape)";
131.     "FS  (file separator)";
132.     "GS  (group separator)";
133.     "RS  (record separator)";
134.     "US  (unit separator)";
135. ]
138. let makeTable dummy =
139.     let mutable sbuf = ""
140.     let mutable abuf = ""
141.     let mutable tbuf = ""
142.     let mutable c = 'a'
144.     sbuf <- "    "
145.     for i in 0..(8-1) do
146.         sbuf <- sbuf +  "+----"
147.     sbuf <- sbuf +  "+"
148.     println(sbuf)
150.     sbuf <- "    "
151.     sbuf <- sbuf +  "| 0- "
152.     sbuf <- sbuf +  "| 1- "
153.     sbuf <- sbuf +  "| 2- "
154.     sbuf <- sbuf +  "| 3- "
155.     sbuf <- sbuf +  "| 4- "
156.     sbuf <- sbuf +  "| 5- "
157.     sbuf <- sbuf +  "| 6- "
158.     sbuf <- sbuf +  "| 7- "
159.     sbuf <- sbuf +  "|"
160.     println(sbuf)
162.     sbuf <- "+---"
163.     for i in 0..(8-1) do
164.         sbuf <- sbuf +  "+----"
165.     sbuf <- sbuf +  "+"
166.     println(sbuf)
168.     for i in 0..(16-1) do
169.         tbuf <- ""
170.         sbuf <- itoa(i, 16)
171.         tbuf <- tbuf +  "| " + sbuf + " "
172.         for j in 0..(8-1) do
173.             if j*16 + i <= 32 then
174.                 abuf <- sprintf "| %-3s" (asc.[j*16 + i])
175.             elif j*16 + i = 127 then
176.                 abuf <- sprintf  "| %-3s" "DEL"
177.             else
178.                 c <- char (j*16 + i)
179.                 abuf <- sprintf "|  %1c " c
180.             tbuf <- tbuf + abuf
181.         tbuf <- tbuf + "|"
182.         println(tbuf)
184.     sbuf <- "+---"
185.     for i in 0..(8-1) do
186.         sbuf <- sbuf + "+----"
187.     sbuf <- sbuf + "+"
188.     println(sbuf)
189.     println("")
191.     for i in 0..(16-1) do
192.         tbuf <- sprintf "%-30s  %-34s" (control.[i]) (control.[i+16])
193.         println(tbuf)
196. // Begin here
197. let cmdArgs = System.Environment.GetCommandLineArgs()
198. if (Array.length cmdArgs > 1 && "-h" = cmdArgs.[1]) then
199.     printUsage 0
200.     exit(1)
202. makeTable 0

컴파일> fsc MakeAsciiTable.fs

실행> MakeAsciiTable

   
    +----+----+----+----+----+----+----+----+
    | 0- | 1- | 2- | 3- | 4- | 5- | 6- | 7- |
+---+----+----+----+----+----+----+----+----+
| 0 | NUL| DLE| Spc|  0 |  @ |  P |  ` |  p |
| 1 | SOH| DC1|  ! |  1 |  A |  Q |  a |  q |
| 2 | STX| DC2|  " |  2 |  B |  R |  b |  r |
| 3 | ETX| DC3|  # |  3 |  C |  S |  c |  s |
| 4 | EOT| DC4|  $ |  4 |  D |  T |  d |  t |
| 5 | ENQ| NAK|  % |  5 |  E |  U |  e |  u |
| 6 | ACK| SYN|  & |  6 |  F |  V |  f |  v |
| 7 | BEL| ETB|  ' |  7 |  G |  W |  g |  w |
| 8 | BS | CAN|  ( |  8 |  H |  X |  h |  x |
| 9 | HT | EM |  ) |  9 |  I |  Y |  i |  y |
| A | LF | SUB|  * |  : |  J |  Z |  j |  z |
| B | VT | ESC|  + |  ; |  K |  [ |  k |  { |
| C | FF | FS |  , |  < |  L |  \ |  l |  | |
| D | CR | GS |  - |  = |  M |  ] |  m |  } |
| E | SO | RS |  . |  > |  N |  ^ |  n |  ~ |
| F | SI | US |  / |  ? |  O |  _ |  o | DEL|
+---+----+----+----+----+----+----+----+----+

NUL (null)                      DLE (data link escape)
SOH (start of heading)          DC1 (device control 1)
STX (start of text)             DC2 (device control 2)
ETX (end of text)               DC3 (device control 3)
EOT (end of transmission)       DC4 (device control 4)
ENQ (enquiry)                   NAK (negative acknowledge)
ACK (acknowledge)               SYN (synchronous idle)
BEL (bell)                      ETB (end of trans. block)
BS  (backspace)                 CAN (cancel)
TAB (horizontal tab)            EM  (end of medium)
LF  (line feed, NL new line)    SUB (substitute, EOF end of file)
VT  (vertical tab)              ESC (escape)
FF  (form feed, NP new page)    FS  (file separator)
CR  (carriage return)           GS  (group separator)
SO  (shift out)                 RS  (record separator)
SI  (shift in)                  US  (unit separator)

컴퓨터 프로그래밍에서 꼭 알아두어야 할 주요 진법은 당연히 10진법, 2진법, 8진법, 16진법이다.
다음은  0 에서 15 까지의 정수를 10진법, 2진법, 8진법, 16진법의 표로 만들어 보여주는 F# 소스 코드이다. 진법 변환에 필요한 함수

        atoi(string, radix)
        itoa(number, radix)

를 F# 코드로 자체 작성하여 사용하였다.

(아래의 소스는 Python 소스를 F# 소스로 일대일 변환 수정한 것이라서, F# 언어의 명령형 언어 특징을 위주로 작성되어 있다.)

1. (*
2.  *  Filename: MakeRadixTable.fs
3.  *            Show the radix table with 10-, 2-, 8-, 16-radices.
4.  *
5.  *  Compile: fsc MakeRadixTable.fs
6.  *  Execute: MakeRadixTable
7.  *
8.  *      Date:  2010/07/15
9.  *    Author:  PH Kim   [ pkim (AT) scripts.pe.kr ]
10.  *)
12. #light
14. exception RuntimeError of string
15. exception ValueError of string
17. let BASE36 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
19. let println s =
20.     printfn "%O" s
22. let print s =
23.     printf "%O" s
25. let printUsage dummy =
26.     println "Usage: MakeRadixTable"
27.     println "Show the radix table with 10-, 2-, 8-, 16-radices."
29. let itoa (num : int, radix : int) =
30.    let mutable isNegative = false
31.    let mutable numx = num
32.    if num < 0 then
33.       isNegative <- true
34.       numx <- (-num)
36.    let mutable arr = [  ]
37.    let mutable q = numx
38.    let mutable r = 0
39.    while (q >= radix) do
40.        r <- int (q % radix)
41.        q <- int (q / radix)
42.        arr <- List.append arr [ sprintf "%O" (BASE36.[r]) ]
44.    arr <- List.append arr [ sprintf "%O" (BASE36.[q]) ]
45.    if isNegative then
46.       arr <- List.append arr [ "-" ]
47.    arr <- List.rev arr
49.    System.String.Join("", List.toArray arr)
52. let atoi (s : string, radix : int) : int =
53.     let mutable ret = 0
54.     let mutable isNegative = false
55.     let len = s.Length
56.     let mutable valx = 0
57.     let mutable c = s.[0]
59.     if c = '-' then
60.         isNegative <- true
61.     elif (c >= '0' && c <= '9') then
62.         ret <- (int c) - (int '0')
63.     elif (c >= 'A' && c <= 'Z') then
64.         ret <- int c - int 'A' + 10
65.     elif (c >= 'a' && c <= 'z') then
66.         ret <- int c - int 'a' + 10
68.     if (ret >= radix) then
69.         printfn "    Error: Can not read \"%s\" (as radix %d): %O is an invalid character!" s radix ret
71.     for i = 1 to len - 1 do
72.         c <- s.[i]
73.         ret <- ret*radix
74.         if (c >= '0' && c <= '9') then
75.             valx <- int c - int '0'
76.         elif (c >= 'A' && c <= 'Z') then
77.             valx <- int c - int 'A' + 10
78.         elif (c >= 'a' && c <= 'z') then
79.             valx <- int c - int 'a' + 10
81.         if (valx >= radix) then
82.             printfn "    Error: Can not read \"%s\" (as radix %d): %O is an invalid character!" s radix c
84.         ret <- ret + valx
86.     if (isNegative) then
87.         ret <- (-ret )
89.     ret
91. let makeTable dummy =
92.     let mutable sbuf = ""
93.     let mutable abuf = ""
94.     let mutable tbuf = ""
96.     for i in 0..(4-1) do
97.         sbuf <- sbuf + "+-------"
98.     sbuf <- sbuf + "+"
99.     println(sbuf)
101.     sbuf <- "|  Dec"
102.     sbuf <- sbuf +  "\t|   Bin"
103.     sbuf <- sbuf +  "\t|  Oct"
104.     sbuf <- sbuf +  "\t|  Hex  |"
105.     println(sbuf)
107.     sbuf <- ""
108.     for i in 0..(4-1) do
109.         sbuf <- sbuf +  "+-------"
110.     sbuf <- sbuf +  "+"
111.     println(sbuf)
113.     for i in 0..(16-1) do
114.         sbuf <- sprintf "|   %2d" i
115.         abuf <- itoa(i, 2)
116.         tbuf <- sprintf "\t|  %4s" abuf
117.         sbuf <- sbuf +  tbuf
119.         abuf <- itoa(i, 8)
120.         tbuf <- sprintf "\t|   %2s" abuf
121.         sbuf <- sbuf + tbuf
123.         abuf <- itoa(i, 16)
124.         tbuf <- sprintf "\t|    %-2s |"  abuf
125.         sbuf <- sbuf +  tbuf
126.         println(sbuf)
128.     sbuf <- ""
129.     for i in 0..(4-1) do
130.         sbuf <- sbuf +  "+-------"
131.     sbuf <- sbuf +  "+"
132.     println(sbuf)
134. // Begin here
135. let cmdArgs = System.Environment.GetCommandLineArgs()
136. if (Array.length cmdArgs > 1 && "-h" = cmdArgs.[1]) then
137.     printUsage 0
138.     exit(1)
140. makeTable 0

컴파일> fsc MakeRadixTable.fs

실행> MakeRadixTable

+-------+-------+-------+-------+
|  Dec  |   Bin |  Oct  |  Hex  |
+-------+-------+-------+-------+
|    0  |     0 |    0  |    0  |
|    1  |     1 |    1  |    1  |
|    2  |    10 |    2  |    2  |
|    3  |    11 |    3  |    3  |
|    4  |   100 |    4  |    4  |
|    5  |   101 |    5  |    5  |
|    6  |   110 |    6  |    6  |
|    7  |   111 |    7  |    7  |
|    8  |  1000 |   10  |    8  |
|    9  |  1001 |   11  |    9  |
|   10  |  1010 |   12  |    A  |
|   11  |  1011 |   13  |    B  |
|   12  |  1100 |   14  |    C  |
|   13  |  1101 |   15  |    D  |
|   14  |  1110 |   16  |    E  |
|   15  |  1111 |   17  |    F  |
+-------+-------+-------+-------+

다음은  대화형 모드(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, 서머타임 적용 여부: 안함