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

* 꼬리 재귀호출과 패턴 매칭을 이용하여 구현한 팩토리얼과 피보나치 수열 계산

크리에이티브 커먼즈 라이선스

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

F# 언어에서 int 타입과 bigint 타입을 상호변환 하는 것은 의외로 쉽다.


명령 프롬프트> fsi

Microsoft (R) F# 2.0 Interactive build 2.0.0.0
Copyright (c) Microsoft Corporation. All Rights Reserved.

For help type #help;;
> let a = 100I;;
val a : System.Numerics.BigInteger = 100I

> let b = int a;;
val b : int = 100

> let c = bigint b;;
val c : System.Numerics.BigInteger = 100I
> b**5;;
  b**5;;
  ^
stdin(13,1): error FS0001: The type 'int' does not support any operators named '
Pow'

> a**5;;
val it : System.Numerics.BigInteger = 10000000000I

> c**5;;
val it : System.Numerics.BigInteger = 10000000000I

> a**5 = c**5;;
val it : bool = true

> let k = int "320";;
val k : int = 320

> let m = bigint "320";;

  let m = bigint "320";;
  --------^^^^^^^^^^^^

stdin(19,9): error FS0041: No overloads match for method 'BigInteger'. The avail
able overloads are shown below (or in the Error List window).
Possible overload: 'System.Numerics.BigInteger()'.
Possible overload: 'new : x:int -> System.Numerics.BigInteger'.
Possible overload: 'new : x:int64 -> System.Numerics.BigInteger'.
Type constraint mismatch. The type
    string
is not compatible with type
    int
The type 'string' is not compatible with the type 'int'
Type constraint mismatch. The type
    string
is not compatible with type
    int64
The type 'string' is not compatible with the type 'int64'

> let m = new System.Numerics.BigInteger("320");;

  let m = new System.Numerics.BigInteger("320");;
  --------^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

stdin(22,9): error FS0041: No overloads match for method 'BigInteger'. The avail
able overloads are shown below (or in the Error List window).
Possible overload: 'System.Numerics.BigInteger()'.
Possible overload: 'new : x:int -> System.Numerics.BigInteger'.
Possible overload: 'new : x:int64 -> System.Numerics.BigInteger'.
Type constraint mismatch. The type
    string
is not compatible with type
    int
The type 'string' is not compatible with the type 'int'
Type constraint mismatch. The type
    string
is not compatible with type
    int64
The type 'string' is not compatible with the type 'int64'

> let m = "320" |> System.Numerics.BigInteger.Parse;;
val m : System.Numerics.BigInteger = 320I

크리에이티브 커먼즈 라이선스

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

정의 (소수와 합성수)
    1보다 큰 양의 정수 n에 대하여
    (i) n = a * b 를 만족하고 1보다 큰 두 양의 정수 a와 b가 존재하면,
        n을 합성수(合成數, composite number)라고 한다. 참고로 이 경우,
        a, b 중에 적어도 하나는 sqrt(n) 보다 작거나 같다.
        합성수의 예로는 4, 6, 9, 24, 143 등이 있다.
    (ii) n = a * b 를 만족하고 1보다 큰 두 양의 정수 a와 b가 존재하지 않으면,
         즉 n을 두 양의 정수의 곱으로 표현하는 방법이 1*n과 n*1 두 가지 뿐이면,
         n을 소수(素數, prime number)라고 한다.  소수의 예로는 2, 3, 5, 7, 11 등이 있다.
         n이 소수인지 아닌지 확인하려면, 
         n을 2 보다 크거나 같고 sqrt(n) 보다 작거나 같은 모든 정수로 나누어 본다.
         이 경우 언제나 나누어 떨어지지  않으면 n은 소수이고, 그렇지 않으면 n은 합성수이다.
    

우선 다음의 F# 소스 코드는 명령행 인자로 전달 받은 양의 정수 n을
2 및 3, 5, 7, ... , sqrt(n) 이하의 홀수들로 나누어 보아 n이 합성수인지 아닌지
확인하는 애플리케이션 소스이다. 확인하는데 걸린 경과 시간도 알려준다.

이제 다음은 정수의 인수분해 능력이 뛰어난  Pollard의 rho 방법(일명 거북이와 토끼 알고리즘, tortoise-hair algorithm)을 구현한  F# 소스 코드이다. 이 알고리즘은 소수에 대해서는 시간이 많이 걸리지만, 합성수에 대해서는 시간이 매우 적게 걸린다는 것이 특징이다.

[파일명:  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  |
+-------+-------+-------+-------+