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

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

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

예외상황 처리 부분 try ... with ... 부분이 아직 미완성이다.

1. (*
2.  *  Filename: makeDivisionTable.ml
3.  *
4.  *  Purpose:  Make a division table in a handy written form.
5.  *
6.  *  Execute: ocaml makeDivisionTable.ml
7.  *
8.  *   Or
9.  *
10.  *  Compile: ocamlc -o makeDivisionTable.exe makeDivisionTable.ml
11.  *  Execute: makeDivisionTable 12345 32
12.  *           makeDivisionTable 500210 61
13.  *           makeDivisionTable 234 55
14.  *
15.  *     Date:  2013. 2. 2.
16.  *   Author:  pkim __AT__ scripts.pe.kr
17.  *)
19. open Printf ;;
21. exception RuntimeError of string
22. exception ValueError of string
24. let sBASE36 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" ;;
25. let sSPACE = "                                                          "  ;;
26. let sULINE = "__________________________________________________________"  ;;
27. let sHIPHEN = "----------------------------------------------------------"  ;;
29. let println s = printf "%s\n" s ;;
31. let print s = printf "%s" s ;;
33. let printUsage() =
34.     (* print("Using: makeDivisionTable [numerator] [denominator]")  *)
35.     (* print("Make a division table in a handy written form.") *)
36.     println "사용법: makeDivisionTable [피제수] [제수]" ;
37.     println "손으로 작성한 형태의 나눗셈 표를 만들어준다." ;;
39. let simplify v width =
40.     let t = [| string_of_int v |] in
41.     let slen = (String.length t.(0)) in
42.     if slen < width then begin
43.         t.(0) <- (String.sub sSPACE 0 (width - slen)) ^ t.(0)
44.     end ;
45.     t.(0) ;;
47. let getSuffix v =
48.     let t = v mod 10  in
49.     let suffix = [| "은" |] in
50.     if (String.contains "2459" (string_of_int  t).[0]) then begin
51.         suffix.(0) <- "는" ;
52.     end ;
53.     suffix.(0) ;;
55. let makeTable numer denom quotient =
56.     let strNumer = sprintf "%d" numer in
57.     let strDenom = sprintf "%d" denom  in
58.     let strQuotient = sprintf "%d" quotient  in
59.     let lenN = String.length strNumer  in
60.     let lenD = String.length strDenom  in
61.     let lenQ = String.length strQuotient  in
62.     let offsetLeft = 3 + lenD + 3  in
63.     let spaces = "                                                                                 "  in
64.     let uline  = String.sub sULINE 0 (lenN + 2)  in
65.     let sline  = String.sub sHIPHEN 0 lenN  in
66.     let bias = lenN - lenQ  in
68.     println ((String.sub spaces 0 offsetLeft) ^ (String.sub spaces 0 bias) ^ (sprintf "%d" quotient)) ;
69.     println ((String.sub spaces 0 (offsetLeft - 2)) ^ uline) ;
70.     print ("   " ^ strDenom ^ " ) " ^ strNumer) ;
72.     let strTmpR = [| String.sub strNumer 0  (bias + 1) |] in
73.     let tmpR = ref (int_of_string strTmpR.(0))  in
74.     let tmpSub = ref 0  in
75.     let oneDigit = [| "" |] in
77.     for i = 0 to (lenQ - 1) do
78.         if (String.sub strQuotient i 1) = "0" then begin
79.             if i + 1 < lenQ then begin
80.                 oneDigit.(0) <- (String.sub  strNumer (bias + i + 1) 1) ;
81.                 printf "%s" oneDigit.(0)  ;
82.                 strTmpR.(0) <- (strTmpR.(0) ^ oneDigit.(0)) ;
83.                 tmpR := int_of_string strTmpR.(0)
84.             end
85.         end
86.         else  begin
87.             print_newline() ;
88.             tmpSub := (int_of_string (String.sub strQuotient i 1)) * denom ;
89.             printf "%s\n" ((String.sub spaces 0 offsetLeft) ^ (simplify !tmpSub  (bias + i + 1)))  ;
90.             printf "%s\n" ((String.sub spaces 0 offsetLeft) ^ sline)  ;
91.             tmpR := !tmpR - !tmpSub  ;
93.             if !tmpR = 0 && i + 1 < lenQ then begin
94.                 printf "%s" ((String.sub spaces 0 offsetLeft) ^ (String.sub spaces 0 (bias + i + 1)) ) ;
95.             end
96.             else begin
97.                 printf "%s" ((String.sub spaces 0 offsetLeft) ^ (simplify !tmpR (bias + i + 1))) ;
98.             end ;
100.             strTmpR.(0) <- sprintf "%d" !tmpR ;
101.             if i + 1 < lenQ then begin
102.                 oneDigit.(0) <- (String.sub strNumer (bias + i + 1) 1) ;
103.                 if  (String.length oneDigit.(0)) > 0 then
104.                     print oneDigit.(0) ;
105.                 strTmpR.(0) <- (strTmpR.(0) ^ oneDigit.(0))
106.             end ;
107.             tmpR := int_of_string strTmpR.(0)
108.         end
109.     done ;
111.     printf "\n" ;
112.     !tmpR ;;
115. let main() =
116.     let cmdArgs = Sys.argv in
117.     if (Array.length cmdArgs < 3 || "-h" = cmdArgs.(1)) then begin
118.         printUsage() ;
119.         exit(1)
120.     end ;
122.     let a = [| 0 |] in
123.     let b = [| 1 |] in
125.     (*
126.     try begin
127.         a.(0) <- int_of_string (cmdArgs.(1)) ;
128.         b.(0) <- int_of_string (cmdArgs.(2)) ;
129.     end
130.     with
131.         | Failure e ->  ( begin
132.                               printf "피제수: %s, 제수: %s\n" (cmdArgs.(1)) (cmdArgs.(2));
133.                               printf "숫자 입력에 오류가 있습니다.\n";
134.                               (* exit(1);  *)
135.                         end; ) ;
136.     *)
137.    
138.     a.(0) <- int_of_string (cmdArgs.(1)) ;
139.     b.(0) <- int_of_string (cmdArgs.(2)) ;
140.     if a.(0) <= 0 then begin
141.         printf "피제수: %d\n" a.(0) ;
142.         printf "피제수는 양의 정수라야 합니다.\n" ;
143.         exit(1)
144.     end
145.     else if b.(0) <= 0 then begin
146.         printf "제수: %d\n" b.(0) ;
147.         printf "제수는 양의 정수라야 합니다.\n" ;
148.         exit(1)
149.     end ;
151.     let q = a.(0) / b.(0) in
152.     let r = a.(0) mod b.(0) in
154.     printf "나눗셈 %d ÷ %d 의 결과: " a.(0) b.(0) ;
155.     printf "몫: %d, " q ;
156.     printf "나머지: %d\n" r ;
157.     print_newline();
159.     let k = makeTable a.(0) b.(0) q in
161.     if k = r then
162.         printf "\n나머지: %d\n" k ;
164.     if k = 0 then begin
165.         printf "%d = %d x %d\n" a.(0) b.(0) q  ;
166.         printf "%d%s %d의 배수(mupltiple)이다.\n" a.(0) (getSuffix a.(0)) b.(0)  ;
167.         printf "%d%s %d의 약수(divisor)이다.\n" b.(0) (getSuffix b.(0)) a.(0)
168.     end
169.     else begin
170.         printf "%d = %d x %d + %d\n" a.(0) b.(0) q r  ;
171.     printf "%d%s %d의 배수(mupltiple)가 아니다.\n" a.(0) (getSuffix a.(0)) b.(0)
172.     end ;;
175. main();;

컴파일> 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)가 아니다.

자리수가 매우 긴 정수(큰 정수, big integer)를 계산하려면

C/C++ 언어로는 gmp 또는 mpir 라이브러리를 쓰면 되고

Java 언어로는 java.math.BigInteger 클래스를 사용하면 되고,

C# 언어로는 System.Numerics.BigInteger 클래스를 사용하면 되고,

Python 언어로는 long 타입(Python 이 자체적으로 알아서 int 타입과 long 타입을 자동 변환함)을쓰면 되고,

Haskell 언어로는 (Int 타입 대신) Integer 타입을 쓰면 된다.

F# 언어의 경우에는 F 샤프 를 참조한다,

그렇다면 OCaml 언어로는 big integer 계산을 어떻게 할까?

답은 의외로 간단하다. 이미 lib 폴더에 설치되어 있는 라이브러리 nums.cma 를 불러 쓰면 된다.

toplevel 에서 사용하거니 ocaml 로 스크립트를 실행할 때는 디렉티브 구문 #load "nums,cma" 를 사용하면 된다. 그러나 ocamlc 명령을 컴파일할 때는 이 디렉티브가 통하지 않으니 이 디렉토리 구문을 주석 처리 하고 컴파일하는 명령줄에 nums.cma 를 추가하면 된다. 이 디렉티브가 없더라도 ocaml 명령으로 스크립트를 실행하는 명령줄에 nums.cma 를 추가하면 된다. 명령 줄에 이를 추가하지 않으면, 정의되지 않은 전역적인(global) Num 을 참조한다는 에러 메시지가 뜬다.

Error: Reference to undefined global `Num'

OCaml 언어에서 big integer 타입의 사칙 연산 기호는 +, -, *, / 가 아니라 +/, -/. */. // 이다. (연산 기호 모두 / 문자가 하나씩 더 붙는다.)

1) 스크립트로 실행하기

    프롬프트> ocaml nums.cma calcBigFactorial.ml

2) 컴파일한 후 실행하기

    프롬프트> ocamlc -o calcBigFactorial.exe nums.cma calcBigFactorial.ml

    프롬프트> calcBigFactorial

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

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

                atoi string  radix
                itoa number radix

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

(아래의 소스는 Python 소스를 F# 소스로 일대일 변환 수정하고, 또 F# 소스를 OCaml 소스로 바꾼 것이라서 명령형 언어 특징을 위주로 작성되어 있다. 그래서 함수형 언어의 관점으로 보면 사이드 이팩트가 많아 난잡하게 보이는 소스이다.)

1. (*
2.  *  Filename: makeAsciiTable.ml
3.  *            Make a table of ascii codes.
4.  *
5.  *  Execute: ocaml makeAsciiTable.ml
6.  *
7.  *    Or
8.  *
9.  *  Compile: ocamlc -o makeAsciiTable.exe makeAsciiTable.ml
10.  *  Execute: makeAsciiTable
11.  *
12.  *      Date:  20013. 1. 29.
13.  *    Author:  pkim __AT__ scripts.pe.kr
14.  *)
16. open Printf;;
18. exception RuntimeError of string
19. exception ValueError of string
21. let println s = printf "%s\n" s ;;
23. let print s = printf "%s" s ;;
25. let printUsage() =
26.     println "Usage: makeAsciiTable" ;
27.     println "Make a table of ascii codes." ;;
29. let split_char sep str =
30.   let rec indices acc i =
31.     try
32.       let i = succ(String.index_from str i sep) in
33.       indices (i::acc) i
34.     with Not_found ->
35.       (String.length str + 1) :: acc
36.   in
37.   let is = indices [0] 0 in
38.   let rec aux acc = function
39.     | last::start::tl ->
40.         let w = String.sub str start (last-start-1) in
41.         aux (w::acc) (start::tl)
42.     | _ -> acc
43.   in
44.   aux [] is ;;
46. let sBASE36 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"  ;;
48. let rec sdup str n =
49.         match n with
50.         | 0 -> ""
51.         | k when k > 0 -> str ^ (sdup str (n - 1))
52.         | _ -> ""
54. let contains s1 s2 =
55.   try
56.     let len = String.length s2 in
57.     for i = 0 to (String.length s1) - len do
58.       if String.sub s1 i len = s2 then raise Exit
59.     done;
60.     false
61.   with Exit -> true ;;
63. let join list sep =
64.     let rec join' list acc =
65.         match list with
66.             | [] -> ""
67.             | [single] -> single
68.             | one::[two] ->
69.                         if acc = "" then one ^ sep ^ two
70.                                     else acc ^ one ^ sep ^ two
71.             | first::others -> join' others (acc ^ first ^ ", ")
72.                                         in
73.                                         join' list "" ;;
75. let str_reverse str =
76.     let len = String.length str in
77.     let res = String.create len in
78.     for i = 0 to pred len do
79.         let j = pred len - i in
80.         res.[i] <- str.[j]
81.     done;
82.     res ;;
84. let itoa num radix =
85.    let isNegative = ref false in
86.    let num1 = num + 0 in
87.    let numx = ref num1 in
89.    if num < 0 then begin
90.       isNegative := true ;
91.       numx := (-num)
92.    end ;
94.    let nnumx = !numx in
96.    let q1 = nnumx in
97.    let q = ref q1 in
98.    let r = ref 0 in
99.    let slen = ref 1 in
101.    while (!q >= radix) do
102.        r := !q mod radix ;
103.        q := !q / radix ;
104.        slen := !slen + 1
105.    done ;
107.    let sslen = !slen in
108.    let str = String.create sslen in
109.    let p1 = nnumx in
110.    let p = ref p1 in
112.    for i = 0 to sslen - 1 do
113.        r := !p mod radix ;
114.        p := !p / radix ;
115.        str.[i] <- sBASE36.[!r]
116.    done ;
118.    let str2 = str_reverse str in
119.    str2;;
121. let atoi s radix =
122.     let ret = ref 0 in
123.     let isNegative = ref false in
124.     let len = String.length s in
125.     let valx = ref 0 in
126.     let c1 = s.[0] in
127.     let c = ref c1 in
129.     if !c = '-' then
130.         isNegative := true
131.     else if (!c >= '0' && !c <= '9') then
132.         ret := (int_of_char !c) - (int_of_char '0')
133.     else if (!c >= 'A' && !c <= 'Z') then
134.         ret := (int_of_char !c) - (int_of_char 'A') + 10
135.     else if (!c >= 'a' && !c <= 'z') then
136.         ret := (int_of_char !c) - (int_of_char 'a') + 10 ;
137.     if (!ret >= radix) then
138.         raise (ValueError (sprintf "Can not read \"%s\" (as radix %d): '%c' is invalid." s radix !c ) ) ;
140.     for i = 1 to len - 1 do
141.         c := s.[i] ;
142.         ret := (!ret)*radix  ;
143.         if (!c >= '0' && !c <= '9') then
144.             valx := int_of_char !c - int_of_char '0' 
145.         else if (!c >= 'A' && !c <= 'Z') then
146.             valx := int_of_char !c - int_of_char 'A' + 10
147.         else if (!c >= 'a' && !c <= 'z') then
148.             valx := int_of_char !c - int_of_char 'a' + 10 ;
149.         if (!valx >= radix) then
150.             raise (ValueError (sprintf "Can not read \"%s\" (as radix %d): '%c' is invalid." s radix !c ) ) ;
151.         ret := (!ret) + (!valx)
152.     done;
154.     if (!isNegative) then
155.         ret := (-(!ret) ) ;
156.     !ret ;;
159. let asc = [|
160.     "NUL"; "SOH"; "STX"; "ETX"; "EOT";
161.     "ENQ"; "ACK"; "BEL"; "BS"; "HT";
162.     "LF"; "VT"; "FF"; "CR"; "SO";
163.     "SI"; "DLE"; "DC1"; "DC2"; "DC3";
164.     "DC4"; "NAK"; "SYN"; "ETB"; "CAN";
165.     "EM"; "SUB"; "ESC"; "FS"; "GS";
166.     "RS"; "US"; "Spc" |] ;;
168. let control = [|
169.     "NUL (null)";
170.     "SOH (start of heading)";
171.     "STX (start of text)";
172.     "ETX (end of text)";
173.     "EOT (end of transmission)";
174.     "ENQ (enquiry)";
175.     "ACK (acknowledge)";
176.     "BEL (bell)";
177.     "BS  (backspace)";
178.     "TAB (horizontal tab)";
179.     "LF  (line feed, NL new line)";
180.     "VT  (vertical tab)";
181.     "FF  (form feed, NP new page)";
182.     "CR  (carriage return)";
183.     "SO  (shift out)";
184.     "SI  (shift in)";
185.     "DLE (data link escape)";
186.     "DC1 (device control 1)";
187.     "DC2 (device control 2)";
188.     "DC3 (device control 3)";
189.     "DC4 (device control 4)";
190.     "NAK (negative acknowledge)";
191.     "SYN (synchronous idle)";
192.     "ETB (end of trans. block)";
193.     "CAN (cancel)";
194.     "EM  (end of medium)";
195.     "SUB (substitute, EOF end of file)";
196.     "ESC (escape)";
197.     "FS  (file separator)";
198.     "GS  (group separator)";
199.     "RS  (record separator)";
200.     "US  (unit separator)" |] ;;
203. let makeTable() =
204.     let sbuf = "    " in
205.     let sbuf = sbuf ^ (sdup "+----" 8) in
206.     let sbuf = sbuf ^  "+" in
207.     println sbuf ;
209.     let sbuf = "    " in
210.     let sbuf = sbuf ^  "| 0- " in
211.     let sbuf = sbuf ^  "| 1- " in
212.     let sbuf = sbuf ^  "| 2- " in
213.     let sbuf = sbuf ^  "| 3- " in
214.     let sbuf = sbuf ^  "| 4- " in
215.     let sbuf = sbuf ^  "| 5- " in
216.     let sbuf = sbuf ^  "| 6- " in
217.     let sbuf = sbuf ^  "| 7- " in
218.     let sbuf = sbuf ^  "|" in
219.     println sbuf  ;
221.     let sbuf = "+---" in
222.     let sbuf = sbuf ^ (sdup "+----" 8) in
223.     let sbuf = sbuf ^  "+" in
224.     println sbuf ;
226.     let aa = Array.make_matrix 16 8 "" in
227.     for i = 0 to (16-1) do
228.         let sbuf = (itoa i 16) in
229.         let tbuf = "| " ^ sbuf ^ " " in
230.         print tbuf ;
231.         for j = 0 to (8-1) do
232.            if j*16 + i <= 32 then
233.                aa.(i).(j) <- sprintf "| %-3s" asc.(j*16 + i)
234.             else if j*16 + i = 127 then
235.                 aa.(i).(j) <- sprintf  "| %-3s" "DEL"
236.             else begin
237.                let c = char_of_int (j*16 + i) in
238.                 aa.(i).(j) <- sprintf "|  %1c " c
239.             end ;
240.             print aa.(i).(j)
241.         done;
242.         println "|"
243.     done ;
245.     let sbuf = "+---" in
246.     let sbuf = sbuf ^ (sdup "+----"  8) in
247.     let sbuf = sbuf ^ "+" in
248.     println sbuf ;
249.     println "" ;
251.     for i = 0 to (16-1) do
252.         let tbuf = sprintf "%-30s  %-34s" control.(i) control.(i+16) in
253.         println tbuf
254.     done ;
255.     "" ;;
258. (* Begin here *)
259. let main() =
260.     let cmdArgs = Sys.argv in
261.     if (Array.length cmdArgs > 1 && "-h" = cmdArgs.(1)) then  begin
262.         printUsage() ;
263.         exit(1)
264.     end ;
265.     makeTable() ;;
267. main() ;;
     

컴파일> ocamlc -o makeAsciiTable.exe makeAsciiTable.ml

실행> 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)

Extlib 는 OCaml 에 붙여 쓰는 여러 가지 (써드 파티) 라이브러리 중의 하나이며, OCaml 의 표준 라이브러리가 지원하지 않는 일들(예를 들면 UTF8 문자 지원)을 한다.

현재 최신 버전인 Extlib 1.5.3 은 OCaml 4.00.0 과 4.00.1 용 라이브러리이고, Extlib 1.5.1, 1.5.2 는 OCaml 3.12.0, 3.12.1 용 라이브러리이다

64비트 윈도우의 경우 Extlib 가 전부 설치되지 못하고, 일부(마이트 코드영 라이브러리, 설치 과정 중 1번 선택)만 설치되는 현상이 있다.

설치하는 명령은 (Extlib 의 압축이 해제된 폴더에서)

    Prompt> ocaml install.ml

이다. 설치 과정 중에  모두(3번)를 선택하여 설치가 실패할 경우에는 1번(바이트 코드)를 선택한다. 설치 후 필요한 것은 라이브러리 파일 extLib,cma 이다. 이 라이브러리 파일이 OCaml 3.12.0 과 3.12.1 의 경우에는 %OCAML설치폴더% 에 생성되지만, OCaml 4.00.0 과 4.00.1 의 경우에는  %OCAML설치폴더%\lib\site-lib\extlib 폴더에 생성된다.

Extlib 의 설치가 성공적으로 끝났으면, 다음 간단한 파일을 작성하고 실행해 보자.

  * 파일명: helloUTF8.ml (파일 저장 시에 UTF8 인코딩로 저장)

ocaml 이나 ocamlc 를 실행할 때는 항상 환경변수 PATH 와 OCAMLLIB 가 알맞게 맞추어져 있는지 확인한다.  ocaml 의 버전을 확인하는 병령은

Prompt> ocaml -version

이다. (참고로 Extlib 가 설치된 직후에는 이 명령이 먹히지 않으므로 새로운 명령창을 열고, PATH 와 OCAMLLIB 를 다시 설정해 준다.)

Prompt> set PATH=C:\OCaml312\bin;%PATH%

Prompt> set OCAMLLIB=C:\OCaml312\lib

* 환경변수 OCAMLLIB 의 설정 확인

Prompt> echo %OCAMLLIB%
C:\OCaml312\lib

* OCaml 3.12.1 에 설치된 Extlib 를 사용하는 실행 명령

Prompt> ocaml -I c:\ocaml312 extLib.cma helloUTF8.ml

실행 결과:
Hello, world!
안녕하세요?
length str = 10
nth str 5 = ?
nth str 5 = 1
nth str 5 = 2
nth str 5 = 3

* OCaml 4.00.1 에 설치된 Extlib 를 사용하는 실행 명령

Prompt> ocaml -I c:\ocaml400\lib\site-lib\extlib extLib.cma helloUTF8.ml

 * 파일명: testDynArray.ml (동적 배열 모튤 DynArray 을 사용하는 OCaml 소스)

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

        int = atoi string radix           (즉, atoi :: string -> int -> int )
        string = itoa number radix    (즉, itoa :: int -> int -> string )

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

(아래의 소스는 Python 소스를 F# 소스로 일대일 변환 수정하고, 또 F# 소스를 OCaml 소스로 바꾼 것이라서 명령형 언어 특징을 위주로 작성되어 있다. 그래서 함수형 언어의 관점으로 보면 사이드 이팩트가 많아 난잡하게 보이는 소스이다.)

1. (*
2.  *  Filename: makeRadixTable.ml
3.  *            Show the radix table with 10-, 2-, 8-, 16-radices.
4.  *
5.  *  Execute: ocaml makeRadixTable.ml
6.  *
7.  *   Or
8.  *
9.  *  Compile: ocamlc -o makeRadixTable.exe makeRadixTable.ml
10.  *  Execute: makeRadixTable
11.  *
12.  *      Date:  2013. 1. 29.
13.  *    Author:  pkim __AT__scripts.pe.kr
14.  *)
16. exception RuntimeError of string
17. exception ValueError of string
19. open Printf ;;
21. let println s = printf "%s\n" s  ;;
23. let print s =  printf "%s" s  ;;
25. let printUsage dummy =
26.     println "Usage: makeRadixTable" ;
27.     println "Show the radix table with 10-, 2-, 8-, 16-radices."  ;;
29. let split_char sep str =
30.   let rec indices acc i =
31.     try
32.       let i = succ(String.index_from str i sep) in
33.       indices (i::acc) i
34.     with Not_found ->
35.       (String.length str + 1) :: acc
36.   in
37.   let is = indices [0] 0 in
38.   let rec aux acc = function
39.     | last::start::tl ->
40.         let w = String.sub str start (last-start-1) in
41.         aux (w::acc) (start::tl)
42.     | _ -> acc
43.   in
44.   aux [] is ;;
46. let sBASE36 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"  ;;
48. let rec sdup str n =
49.         match n with
50.         | 0 -> ""
51.         | k when k > 0 -> str ^ (sdup str (n - 1))
52.         | _ -> ""
54. let contains s1 s2 =
55.   try
56.     let len = String.length s2 in
57.     for i = 0 to (String.length s1) - len do
58.       if String.sub s1 i len = s2 then raise Exit
59.     done;
60.     false
61.   with Exit -> true ;;
63. let join list sep =
64.     let rec join' list acc =
65.         match list with
66.             | [] -> ""
67.             | [single] -> single
68.             | one::[two] ->
69.                         if acc = "" then one ^ sep ^ two
70.                                     else acc ^ one ^ sep ^ two
71.             | first::others -> join' others (acc ^ first ^ ", ")
72.                                         in
73.                                         join' list "" ;;
75. let str_reverse str =
        let len = String.length str in
76.     let res = String.create len in
77.     for i = 0 to pred len do
78.         let j = pred len - i in
79.         res.[i] <- str.[j]
80.     done;
81.     res ;;
83. let itoa num radix =
84.    let isNegative = ref false in
85.    let num1 = num + 0 in
86.    let numx = ref num1 in
88.    if num < 0 then begin
89.       isNegative := true ;
90.       numx := (-num)
91.    end ;
93.    let nnumx = !numx in
95.    let q1 = nnumx in
96.    let q = ref q1 in
97.    let r = ref 0 in
98.    let slen = ref 1 in
100.    while (!q >= radix) do
101.        r := !q mod radix ;
102.        q := !q / radix ;
103.        slen := !slen + 1
104.    done ;
106.    let sslen = !slen in
107.    let str = String.create sslen in
109.    let p1 = nnumx in
110.    let p = ref p1 in
112.    for i = 0 to sslen - 1 do
113.        r := !p mod radix ;
114.        p := !p / radix ;
115.        str.[i] <- sBASE36.[!r]
116.    done ;
118.    let str2 = str_reverse str in
119.    str2;;
121. let atoi s radix =
122.     let ret = ref 0 in
123.     let isNegative = ref false in
124.     let len = String.length s in
125.     let valx = ref 0 in
126.     let c1 = s.[0] in
127.     let c = ref c1 in
129.     if !c = '-' then 
130.        isNegative := true
131.     else if (!c >= '0' && !c <= '9') then
132.         ret := (int_of_char !c) - (int_of_char '0')
133.     else if (!c >= 'A' && !c <= 'Z') then
134.         ret := (int_of_char !c) - (int_of_char 'A') + 10
135.     else if (!c >= 'a' && !c <= 'z') then
136.         ret := (int_of_char !c) - (int_of_char 'a') + 10 ;
137.     if (!ret >= radix) then
138.         raise (ValueError (sprintf "Can not read \"%s\" (as radix %d): '%c' is invalid." s radix !c ) ) ;
140.     for i = 1 to len - 1 do
141.         c := s.[i] ;
142.         ret := (!ret)*radix  ;
143.         if (!c >= '0' && !c <= '9') then
144.             valx := int_of_char !c - int_of_char '0' 
145.         else if (!c >= 'A' && !c <= 'Z') then
146.             valx := int_of_char !c - int_of_char 'A' + 10
147.         else if (!c >= 'a' && !c <= 'z') then
148.             valx := int_of_char !c - int_of_char 'a' + 10 ;
149.         if (!valx >= radix) then 
                 raise (ValueError (sprintf "Can not read \"%s\" (as radix %d): '%c' is invalid." s radix !c ) ) ;
150.         ret := (!ret) + (!valx)
151.     done;
153.     if (!isNegative) then
154.         ret := (-(!ret) ) ;
156.     !ret ;;
159. let makeTable() =
160.     let sbuf = "" in
161.     let sbuf = sbuf ^ (sdup "+-------" 4) in
162.     let sbuf = sbuf ^ "+" in
163.     println sbuf ;
165.     let sbuf = "|  Dec" in
166.     let sbuf = sbuf ^  "\t|   Bin" in
167.     let sbuf = sbuf ^  "\t|  Oct" in
168.     let sbuf = sbuf ^  "\t|  Hex  |" in
169.     println sbuf ;
171.     let sbuf = ""  in
172.     let sbuf = sbuf ^ (sdup "+-------" 4) in
173.     let sbuf = sbuf ^  "+" in
174.     println sbuf ;
176.     for i = 0 to (16-1) do
177.         let sbuf = sprintf "|   %2d" i in
178.         let abuf = itoa i 2  in
179.         let tbuf = sprintf "\t|  %4s" abuf   in
180.         let sbuf = sbuf ^ tbuf   in
181.         let abuf = itoa i 8    in
182.         let tbuf = sprintf "\t|   %2s" abuf    in
183.         let sbuf = sbuf ^ tbuf    in
184.         let abuf = itoa i 16    in
185.         let tbuf = sprintf "\t|    %-2s |"  abuf    in
186.         let sbuf = sbuf ^  tbuf    in
187.         println sbuf
188.     done ;
190.     let sbuf = "" in
191.     let sbuf = sbuf ^ (sdup  "+-------" 4) in
192.     let sbuf = sbuf ^  "+" in
193.     println sbuf ;
194.     "" ;;
197. let main() =
198.     let cmdArgs = Sys.argv in
199.     if (Array.length cmdArgs > 1 && "-h" = cmdArgs.(1)) then begin
200.         printUsage() ;
201.         exit(1)
202.     end ;
203.     makeTable() ;;
205. main()

실행 결과:

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

   주: 이 소스는 Python 용으로 만들어 둔 소스를 F# 언어로 바꾸고, 다시 이를 Ocaml
        언어로 바꾸느라 OCaml 언어의 명령형 언어 특징을 위주로 짜여져 있다.

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

         let value = atoi str srcRdx
         let str = itoa value destRdx

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

1. (*
2.  *  Filename: convertRadix.ml
3.  *            Convert radix in an interactive mode.
4.  *
5.  *  Execute: ocaml convertRadix.ml
6.  *
7.  *   Or
8.  *
9.  *  Compile: ocamlc -o convertRadix.exe convertRadix.ml
10.  *  Execute: convertRadix
11.  *
12.  *      Date:  2013. 1. 28.
13.  *    Author:  P. Kim   ( pkim _AT_ scripts.pe.kr )
14.  *)
16. open Printf;;
18. exception RuntimeError of string
19. exception ValueError of string
20. exception Exit
22. let println s =
23.     printf "%s\n" s ;;
25. let print s =
26.    printf "%s" s  ;;
28. let printUsage() =
29.     println "Usage: convertRadix" ;
30.     println "Convert radix in a interactive mode, where the maximum radix is 36." ;;
32. let printAbout() =
33.     println "    About: Convert radix in a interactive mode."  ;;
35. let printMainMenu() =
36.     println "  Command: (S)et radix, (A)bout, (Q)uit or E(x)it"  ;;
38. let printMainPrompt() =
39.     print "  Prompt> "  ;;
41. let printSubMenu srcRadix destRadix =
42.     println (sprintf "    Convert Radix_%d to Radix_%d\n" srcRadix destRadix )  ;
43.     println ("    SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit" )  ;;
45. let printSubPrompt() =
46.     print "    Input Value>> " ;;
48. let split_char sep str =
49.   let rec indices acc i =
50.     try
51.       let i = succ(String.index_from str i sep) in
52.       indices (i::acc) i
53.     with Not_found ->
54.       (String.length str + 1) :: acc
55.   in
56.   let is = indices [0] 0 in
57.   let rec aux acc = function
58.     | last::start::tl ->
59.         let w = String.sub str start (last-start-1) in
60.         aux (w::acc) (start::tl)
61.     | _ -> acc
62.   in
63.   aux [] is ;;
65. let sBASE36 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"  ;;
67. let contains s1 s2 =
68.   try
69.     let len = String.length s2 in
70.     for i = 0 to (String.length s1) - len do
71.       if String.sub s1 i len = s2 then raise Exit
72.     done;
73.     false
74.   with Exit -> true ;;
76. let join list sep =
77.     let rec join' list acc =
78.         match list with
79.             | [] -> ""
80.             | [single] -> single
81.             | one::[two] ->
82.                         if acc = "" then one ^ sep ^ two
83.                                     else acc ^ one ^ sep ^ two
84.             | first::others -> join' others (acc ^ first ^ ", ")
85.                                         in
86.                                         join' list "" ;;
88. let str_reverse str =
89.     let len = String.length str in
90.     let res = String.create len in
91.     for i = 0 to pred len do
92.         let j = pred len - i in
93.         res.[i] <- str.[j]
94.     done;
95.     res ;;
98. let itoa num radix =
99.    let isNegative = ref false in
100.    let num1 = num + 0 in
101.    let numx = ref num1 in
103.    if num < 0 then begin
104.       isNegative := true ;
105.       numx := (-num)
106.    end ;
108.    let nnumx = !numx in
110.    let q1 = nnumx in
111.    let q = ref q1 in
112.    let r = ref 0 in
113.    let slen = ref 1 in
115.    while (!q >= radix) do
116.        r := !q mod radix ;
117.        q := !q / radix ;
118.        slen := !slen + 1
119.    done ;
121.    let sslen = !slen in
123.    let str = String.create sslen in
124.    let p1 = nnumx in
125.    let p = ref p1 in
127.    for i = 0 to sslen - 1 do
128.        r := !p mod radix ;
129.        p := !p / radix ;
130.        str.[i] <- sBASE36.[!r]
131.    done ;
133.    let str2 = str_reverse str in
134.    str2;;
136. let atoi s radix =
137.     let ret = ref 0 in
138.     let isNegative = ref false in
139.     let len = String.length s in
140.     let valx = ref 0 in
141.     let c1 = s.[0] in
142.     let c = ref c1 in
144.     if !c = '-' then
145.         isNegative := true
146.     else if (!c >= '0' && !c <= '9') then
147.         ret := (int_of_char !c) - (int_of_char '0')
148.     else if (!c >= 'A' && !c <= 'Z') then
149.         ret := (int_of_char !c) - (int_of_char 'A') + 10
150.     else if (!c >= 'a' && !c <= 'z') then
151.         ret := (int_of_char !c) - (int_of_char 'a') + 10 ;
152.     if (!ret >= radix) then 
153.         raise (ValueError (sprintf "Can not read \"%s\" (as radix %d): '%c' is invalid." s radix !c ) ) ;
155.     for i = 1 to len - 1 do
156.         c := s.[i] ;
157.         ret := (!ret)*radix  ;
158.         if (!c >= '0' && !c <= '9') then
159.             valx := int_of_char !c - int_of_char '0' 
160.         else if (!c >= 'A' && !c <= 'Z') then
161.             valx := int_of_char !c - int_of_char 'A' + 10
162.         else if (!c >= 'a' && !c <= 'z') then
163.             valx := int_of_char !c - int_of_char 'a' + 10 ;
164.         if (!valx >= radix) then 
165.             raise (ValueError (sprintf "Can not read \"%s\" (as radix %d): '%c' is invalid." s radix !c ) ) ;
166.         ret := (!ret) + (!valx)
167.     done;
169.     if (!isNegative) then
170.         ret := (-(!ret) ) ;
172.     !ret ;;
175. let convertRadix s srcRdx destRdx =
176.     let valx = (atoi s srcRdx) in
177.     let ret = (itoa valx destRdx) in
178.     let ret2 = String.uppercase ret in
179.     ret2 ;;
182. let doConvert srcRadix destRadix =
183.     println "" ;
185.     printSubMenu srcRadix  destRadix ;
186.     let stop_flag = ref false in
187.     try
188.         while not (!stop_flag) do
189.             printSubPrompt() ;
190.             let tt = read_line() in
191.             let cmd = ref tt in
193.             while (String.length !cmd) = 0 do
194.                 let tt2 = read_line() in
195.                 cmd := tt2
196.             done;
198.             if "main()" = !cmd then begin
199.                 stop_flag := true ;
200.                 raise ( RuntimeError "" )
201.             end
202.             else if "exit()" = !cmd || "quit()" = !cmd then begin
203.                 exit 0
204.             end ;
206.             try 
207.                 let srcStr = !cmd in
208.                 let destStr = (convertRadix srcStr srcRadix destRadix) in
209.                 println (sprintf "        ( %s )_%d   --->   ( %s )_%d" srcStr srcRadix destStr destRadix ) ;
210.                 println ""
211.             with ValueError ex -> println (sprintf "    Error caused by: %s\n"  ex)
212.         done
213.     with RuntimeError ex -> println (sprintf " %s     "  ex);
214.     println "" ;;
217. let doStart() =
218.     let onlyOnce = ref true in
220.     try
221.         while true do
222.             print "" ;
223.             if (!onlyOnce) then begin
224.                 println "  The supported maximum radix is 36." ;
225.                 onlyOnce := false
226.             end ;
228.             printMainMenu() ;
229.             printMainPrompt() ;
231.             let tcmds = read_line() in
232.             let cmds = ref tcmds in
233.             while (String.length !cmds) = 0 do
234.                 let tt = read_line() in
235.                 cmds := tt
236.             done;
238.             let cmd = !cmds.[0] in
239.             if (contains  "qQxX" (sprintf "%c" cmd)) && (String.length !cmds) = 1 then begin
240.                 exit 0
241.             end
242.             else if (contains  "aA" (sprintf "%c" cmd)) && (String.length !cmds) = 1 then begin
243.                 printAbout()
244.             end
245.             else if (contains  "sS" (sprintf "%c" cmd)) && (String.length !cmds) = 1 then begin
246.                 print "  Input the source and target radices (say, 16 2): "  ;
247.                 let tt = read_line() in
248.                 let line = ref tt in
249.                 let ta = (split_char ' ' !line) in
250.                 let st = ref ta in
252.                 while (List.length !st) < 2 do
253.                     print "  Input the source and target radices (say, 16 2): "  ;
254.                     let tt2 = read_line() in
255.                     let ta2 = (split_char ' ' tt2) in
256.                     st := ta2
257.                 done;
259.                 let st2 = Array.of_list !st in
260.                 let srcRadix = int_of_string (st2.(0)) in
261.                 let destRadix = int_of_string (st2.(1)) in
262.                 doConvert srcRadix destRadix
263.             end ;
264.             print ""
265.        done 
266.     with RuntimeError ex -> println (sprintf "%s Error found!!" ex);;
269. (* Begin here *)
270. let main() =
271.     let cmdArgs = Sys.argv in
272.     if (Array.length cmdArgs > 1) && ("-h" = cmdArgs.(1)) then begin
273.         printUsage() ;
274.         exit 1
275.     end
276.     else begin
277.         doStart()
278.     end ;;
280. main();;
     

컴파일> ocamlc -o convertRadix.exe convertRadix.fs

실행> convertRadix

  The supported maximum radix is 36.
  Command: (S)et radix, (A)bout, (Q)uit or E(x)it
  Prompt> s
  Input the source and target radices (say, 16 2): 10 8

    Convert Radix_10 to Radix_8

    SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit
    Input Value>> 200
        ( 200 )_10   --->   ( 310 )_8

    Input Value>> main()

  Command: (S)et radix, (A)bout, (Q)uit or E(x)it
  Prompt> S
  Input the source and target radices (say, 16 2): 8 10

    Convert Radix_8 to Radix_10

    SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit
    Input Value>> 2666
        ( 2666 )_8   --->   ( 1462 )_10

    Input Value>> main()

  Command: (S)et radix, (A)bout, (Q)uit or E(x)it
  Prompt> x

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

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

1. (*
2.  *  Filename: testGoldenRatio.ml
3.  *    황금률(즉, 이차방정식 x^2 - x - 1  = 0 의 양의 근)을 계산한다.
4.  *
5.  *   Execute: ocaml testGoldenRatio.ml
6.  *
7.  *   Compile: ocamlc -o testGoldenRatio.exe testGoldenRatio.ml
8.  *   Execute: testGoldenRatio
9.  *
10.  *      Date:  2013/01/27
11.  *    Author: P. Kim   [ pkim _AT_ scripts.pe.kr ]
12.  *)
14. open Printf;;
16. let printUsing() =
17.     printf "Using: TestGoldenRatio [-h|-help]\n" ;
18.     printf "This calculates the value of the golden ratio.\n" ;;
20. exception ZeroCoefficientException;;
21. exception NegativeDiscriminantException;;
23. (* 이차방정식 a x^2 + b x + c  = 0 의 근을 구한다. *)
24. let findQuadraticRoot a b c =
25.     if a = 0.0 then begin
26.         raise ZeroCoefficientException
27.     end
28.     else if (b*.b -. 4.0*.a*.c < 0.0) then begin
29.         raise NegativeDiscriminantException
30.     end;
32.     let x1 = ((-.b) +. (sqrt (b*.b -. 4.0*.a*.c))) /. (2.0 *. a) in
33.     let x2 = ((-.b) -. (sqrt (b*.b -. 4.0*.a*.c))) /. (2.0 *. a) in
34.     x1, x2  ;;  (* 리턴 겂 두 개 *)
36. (* 실행 시작 지점 *)
37. let cmdArgs = Sys.argv;;
38. if (Array.length cmdArgs > 1) && (cmdArgs.(1) = "-h" || cmdArgs.(1) = "-help") then
39. begin
40.     printUsing();
41.     exit 1
42. end ;;
44. let x1, x2  = findQuadraticRoot 1.0  (-1.0)  (-1.0) ;;
46. if x1 >= x2 then begin
47.     printf "The bigger root is %g " x1 ;
48.     printf "and the less root is %g.\n" x2
49. end
50. else begin
51.     printf "The bigger root is %g, " x2 ;
52.     printf "and the less root is %g.\n" x1
53. end ;;

컴파일> ocamlc -o testGoldenRatio.exe testGoldenRatio.ml

실행> testGoldenRatio
The bigger root is 1.61803 and the less root is -0.618034.

현재 시각을 컨솔에 보여주는 간단한 OCaml 언어 소스 코드이다.
UTC란 1970년 1월 1일 0시 0분 0초를 기준으로 하여 경과된 초 단위의 총 시간을 의미한다.
UTC(Universal Time  Coordinated, 협정세계시, 協定世界時)

1. (*
2.  *  Filename: testCTimeApp.ml
3.  *
4.  *  Execute: Uncomment the line (* #load "unix.cma" ;; *)
5.  *           ocaml testCTimeApp.ml
6.  *
7.  *  Compile: ocamlc -g -c testCTimeApp.ml
8.  *           ocamlc -o testCTimeApp.exe unix.cma testCTimeApp.cmo
9.  *  Execute: testCTimeApp 
10.  *)
12. (* #load "unix.cma" ;; *)    (* ocaml 로 실행 시에는 이 곳의 주석 표시 제거 *)
14. open Unix ;;
15. open Printf;;
17. let weekNames = [| "일"; "월"; "화"; "수"; "목"; "금"; "토" |]
19. let now = Unix.time ()
21. let {Unix.tm_sec=seconds; tm_min=minutes; tm_hour=hours;
22.      tm_mday=day_of_month; tm_mon=month; tm_year=year;
23.      tm_wday=wday; tm_yday=yday; tm_isdst=isdst} =
24.   Unix.localtime now
26. let startOfEpoch = mktime (localtime (time ())) ;;
28. (* 1970년 1월 1일 0시 0분 0초부터 시작하여 현재까지의 초 *)
29. let () = printf "UTC: %.0f\n" (fst startOfEpoch)
31. (* 현재 시각 표시: 20xx년 xx월 xx일 (x요일) xx시 xx분 xx초 *)
32. let () = printf "%d년 " (1970 + year)
33. let () = printf "%d월 " (1 + month)     (* Not 1 + now.Month !! *)
34. let () = printf "%d일 " (day_of_month)
35. let () = printf "(%s요일) " (weekNames.(wday))
36. let () = printf "%d시 " (hours)
37. let () = printf "%d분 " (minutes)
38. let () = printf "%d초" (seconds)
39. let () = print_newline()
41. (* 1월 1일은 1, 1월 2일은 2 *)
42. let () = printf "올해 몇 번째 날: %d, " (yday)
43. (* true 이면 서머타임 있음 *)
44. let str = if not (isdst) then "안함" else "함"
45. let () = printf "서머타임 적용 여부: %s\n"  str

컴파일> ocamlc -o testCTimeApp.exe testCTimeApp.ml

실행> testCTimeApp
UTC: 1359278723
2083년 1월 27일 (일요일) 18시 25분 23초
올해 몇 번째 날: 26, 서머타임 적용 여부: 안함

F# 용 소스파일 testForFor.fs 를 OCaml 용으로 수정한 것이다.
F# 언어는 if 구문, for 구문, 들여쓰기 규칙이 Python의 것과 닮았지만, OCam 언어는 (C 언어 처럼) 들여쓰기 규칙이 없다. 그 대신 구문의 끝을 한 개의 세미콜론(;)으로 끝낼지, 두 개의 세미콜론(;;)으로 끝낼지, 아니면 세미콜론을 안 붙일 것이지를 정확하게 지켜야 한다. OCam 언어는 let 으로 시작하는 구문에 세미콜론 없이 예약어 in 으로 (정의가) 계속 이어지는 구문도 많이 쓰인다.

두 개의 세미콜론(;;) 으로 끝나는 곳이 정의가 완전히 끝난 곳임을 알리는 구문이고, 한 개의 세미 콜론으로 끝나는 곳은 정의가 아직 완성 도지 않았으니 무시하라는 구문이다.

아래는 ocaml 을 실행시켜서서 (대화영 모드에서) 예약어 in 의 역할을 테스트한 내용이다.

OCaml 언어는 (F# 언어 처럼) 함수형 언어기도 하고 명령형 언어이기도 하므로, 여기서는 가급적 OCaml 의 명령형 언어의 특징을 위주로 작성하였다.

1. (* 
2.  *  Filename: testForFor.ml
3.  *
4.  *         이겹 for 반복문을 사용하여 19단표를 컨솔에 출력한다.
5.  *
6.  *   Execute: ocaml testForFor.ml
7.  *
8.  *    Or
9.  *
10.  *   Compile: ocamlc -o testForFor.exe testForFor.ml
11.  *   Execute: testForFor
12.  *
13.  *  Date:  2013. 1. 27.
14.  *)
16. let getDan dan = 
17.     let t = Array.make 19 "" in
18.     for j = 0 to (19 - 1) do
19.         let sa = Printf.sprintf "%2d" dan in
20.         let sb = Printf.sprintf "%2d" (j + 1) in
21.         let sval = Printf.sprintf "%3d" (dan*(j + 1)) in
22.         t.(j) <- Printf.sprintf ("%s x %s = %s") sa sb sval
23.     done;
24.     t;;  (* 리턴 값.  함수의 정의가 여기서 완전히 끝나므로 두 개의 세미콜론 *)
26. (* 19단표를 모두 80컬럼 컨솔에 출력한다. *)
27. let printAllNineteenDan() =    (* OCaml 소스 코드에서는 (F# 소스 코드에서 처럼) 리스트 대신 배열을 사용한다. *)
28.     let arr = Array.make_matrix 18 19 "aa" in
29.     for i = 2 to (20 - 1) do
30.         arr.(i - 2) <- (getDan i );
31.     done;
33.     let d = [| 2; 7; 11; 16 |] in       (* 각 줄단위 블럭의 첫단 *)
34.     let counter = [| 5; 4; 5; 4 |] in         (* 각 줄단위 블럭에 속한 단의 개수 *)
35.     let lines = Array.make 19 "" in
37.     for k = 0 to ((Array.length d) - 1) do
38.         (* 8-바이트 길이의 한 줄씩 완성 *)
39.         for i = 0 to (19 - 1) do
40.             lines.(i) <- (arr.(d.(k)-2).(i));
41.             for j = 1 to (counter.(k) - 1) do
42.                 lines.(i) <- Printf.sprintf ("%s   %s") lines.(i) arr.(d.(k)-2+j).(i)
43.             done;
44.         done;
46.         (* 80 바이트 길이의 한 줄씩 출력 *)
47.         for i = 0 to (19 - 1) do
48.             Printf.printf "%s\n" (lines.(i))
49.         done;
50.         Printf.printf "\n";
51.     done;;
53. printAllNineteenDan();;
    

컴파일: 
Prompt> ocamlc -o testForFor.exe testForFor.ml 

실행: 
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.ml

1. (*
2.  *  Filename: testNoWhile.ml
3.  *
4.  *  Purpose:  Example not using the while loop syntax 
5.  *                while ....
6.  * 
7.  *  Execute: ocaml testNoWhile.ml -200 300
8.  * 
9.  *    Or
10.  * 
11.  *  Compile: ocamlc -o testNoWhile.exe testNoWhile.ml
12.  *  Execute: testNoWhile -200 300
13.  *)
15. (* 사용법 표시 *)
16. let printUsage() =
17.     Printf.printf "Using: testNoWhile.py [integer1] [integer2]\n";
18.     Printf.printf "This finds the greatest common divisor of the given two integers.\n";;
20. let cmdArgs = Sys.argv;; 
21. if not ((Array.length cmdArgs) == 3) then
22.     printUsage();
24. if not ((Array.length cmdArgs) == 3) then
25.     exit 1;;
27. (*
28. // --------------------------------------
29. // 명령행 인자의 두 스트링을 가져와서
30. // 정수 타입으로 변환하여
31. // 변수 val1과 val2에 저장한다.
32. *)
34. let val1 = int_of_string cmdArgs.(1);;
35. let val2 = int_of_string cmdArgs.(2);;
37. let a = ref (abs val1);;
38. let b = ref (abs val2);;
40. let max x y = if y > x then y else x;;
41. let min x y = if y > x then x else y;;
43. let maxab = max !a !b;;
44. let minab = min !a !b;;
46. (* a는 |val1|, |val2| 중 큰 값 *)
47. a := maxab;;
48. b := minab;;
50. (*
51. // --------------------------------------
52. // 재귀호출 Euclidean 알고리즘
53. //
54. //     Euclidean 알고리즘의 반복 (나머지가 0이 될 때 까지)
55. //     나머지가 0이면 그 때 나눈 수(제수) x가 최대공약수(GCD)이다.
56.  *)
57. let rec gcdRecursive x y =
58.     match y with
59.     | 0 -> x
60.     | _ -> gcdRecursive y (x mod y);;
62. let gcd = gcdRecursive !a !b;;
64. (* 최대공약수(GCD)를 출력한다. *)
65. Printf.printf "GCD(%d, %d) = %d\n" val1 val2 gcd;
66. exit 0;;

컴파일:
Command> ocamlc -o testNoWhile.exe 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