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

음이 아닌 실수 A 의 평방근 sqrt(A) 를 구하는 Heron 의 방법:

        반복함수  g(x) = (x + A/x) / 2   를 이용

실수 A 의 n제곱근 root(n, A) 를 구하는 Newton-Raphson 의 방법

        반복함수  g(x) = ((n-1)*x + A/(x**(n - 1))) / n    를 이용

n = 2 인 경우에는 Newton-Raphson 의 방법이 Heron 의 방법과 동일하다.

(참조. http://en.wikipedia.org/wiki/Newton's_method )

Scala 언어에는 지수 계산을 위한 함수 scala.math.pow(밑수, 지수) 가 이미 구현되어 있다. 하지만 차후 필요한 데가 있을 것 같아서 이와 유사한 n 제곱 함수와 n 제곱근 함수를 구현해 보았다.

지수가 정수인 거듭제곱을 계산하는  함수도 nPow(), gPow, mPow() 세 개 구현해 놓았는데, 이들 세 함수는 절차적 언어의 성능상 재귀호출이 아니고 단순 반복 기법을 사용하는 함수이다. 이 세 함수 중 mPow() 의 성능이 가장 우수하다. 큰 지수의 경우 for 반복문의 반복회수를 따져 보면 성능 비교를 할 수 있을 것이다. (성능 비교를 위해 세 가지를 모두 소스에 남겨 두었다.) mPow() 함수는 n 제곱근을 구하는 재귀함수 newtonNthRoot(int, double) 의 구현에 사용되기도 한다. if ... else ... 구문이 많아 소스가 복잡하게 보일지 모르겠으나 이는 밑수나 지수가 음수이거나 0인 경우의 처리를 위함이다. 구현된 모든 함수의 구현에는 예외상황(예를 들어, 음수의 짝수 제곱근 같은 예외상황) 처리 과정이 있다.

1. Scala 언어는 JVM(자바가상기계) 위에서 동작하는 (절차적 프로그래밍도 지원하는) 함수형 언어이다.

   하지만, 아래의 소스에서는 함수형 언어의 기능은 거의 사용하지 않앗고, 절차적 언어의 기능을 위주로 사용하였다. 하나의 함수를 구현하는데 함수형 기능과 절차적 기능을 섞어서 사용하는 것은 좋지 않은 습관이다.

2. Scala  언어는 타입에 동적인(dynamic) 언어이다. 변수 선언시에 타입을 지정하지 않아도 된다.

3. Scala  언어에서는 val 로 선언 된 것은 상수, var 로 선언된 것은 변수이다.

     val a = 2.7      // a 상수
     var b = 5.3     // b 는 변수 

아래의 소스 첫 부분에

        val MAX_ITER = 20000
        val M_EPSILON = 1.0e-15
       

라고 선언하였으니, MAX_ITER 와 M_EPSILON 는 상수로 선언되었다.

4. Scala 언어에는 return 이라는 예약어가 없다. 그냥 리턴될 값만 수식으로 표현해 놓으면, Scala 컴파일러(또는 Scala 인터프리터)가 리턴될 값을 알아서 인식하고 처리해 준다.

5. 예외상황 처리를 위해 예외 던지기 구문 throw ... 와 예외 받기 구문 try ... catch ...을 이용하였다.

역삼각함수란 삼각함수의 역함수를 의미하고,

역쌍곡선함수란 쌍곡선함수의 역함수를 의미한다.

수학에서 sin 함수의 역함수는 arcsin 으로 표기되는데,

Scala 언어에서는 scala.math.asin(Double) 메소드로 구현되어 있다.

1. /*
2.  *  Filename: guessNumber01.scala
3.  *  Purpose:  Interatice game guessing a given number.
4.  *                if {CONDITION) {
5.  *                    ......
6.  *                }
7.  *                else {
8.  *                    ......
9.  *                }
10.  *  Execute: scala -encoding MS949 guessNumber01.scala
11.  */
13. import java.io._
14. import java.util._
16. def doGuessing(num: Int) {
17.     println("Enter your guess:")
18.     var r : BufferedReader = new BufferedReader(new InputStreamReader(System.in))
19.     var sbuf = r.readLine()
20.     var guess = Integer.parseInt(sbuf)
21.     if (guess == num) {
22.         println("You win!")
23.         return
24.     }
26.     // we won't get here if guess == num
27.     if (guess < num) {
28.         println("Too low!")
29.         doGuessing(num)
30.     }
31.     else {
32.         println("Too high!")
33.         doGuessing(num)
34.     }
35. }
37. doGuessing(123)

실행> scala -encoding MS949 guessNumber01.scala
Enter your guess:
111
Too low!
Enter your guess:
222
Too high!
Enter your guess:
123
You win!





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

Scala 언어로는 리스트 대신 배열로 처리하였다.
 
[파일명:  testStringFindInArray.scala]------------------------------------------------
object TestStringFindInArray {
    def quickSort(arr: Array[String], start: Int, end: Int) {
        var i: Int = start
        var k: Int = end
        var pivot: String = ""

        if (end - start >= 1) {
            pivot = arr(start)
            while (k > i) {
                 while (arr(i) <= pivot && i <= end && k > i) {
                     i += 1
                 }
                 while (arr(k) > pivot && k >= start && k >= i) {
                     k -= 1
                 }
                 if (k > i) {
                     swap(arr, i, k)
                 }
             }
            swap(arr, start, k)

            quickSort(arr, start, k - 1)
            quickSort(arr, k + 1, end)
        }
    }

    def swap(arr: Array[String], x: Int, y: Int) {
        var tmp: String = arr(x)
        arr(x) = arr(y)
        arr(y) = tmp
    }

    def find(arr: Array[String], s: String): Int = {
        var i: Int = 0
        for (i <- 0 to arr.length - 1) {
        if (arr(i).indexOf(s) >= 0) {
     return i
        }
        }
    return -1
    }

    def printArray(arr: Array[String]) {
        print("[")
        for (i <- 0 to arr.length - 2) {
           print(arr(i) + ", ")
        }
        println(arr(arr.length - 1) + "]")
    }

    def main(args: Array[String]) {
        var words: Array[String] = Array[String]( "하나", "둘", "셋", "넷", "다섯", "여섯" )
        var where: Int = 0

        print("array: ")
        printArray(words)

        where = find(words, "셋")
        if (where > 0) {
            print("발견!  ")
            println("Next word of 셋 in array: " + words(where+1))
        }

        quickSort(words, 0, words.length - 1)

        print("array: ")
        printArray(words)

        where = find(words, "셋")
        if (where > 0) {
            print("발견!  ")
            println("Next word of 셋 in array: " + words(where+1))
        }
    }
}
------------------------------------------------


컴파일> scalac -encoding ms949 testStringFindInArray.scala

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

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

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

[파일명:  TestSort.scala]------------------------------------------------
object TestSort {
    def quickSort(arr: Array[String], start: Int, end: Int) {
        var i: Int = start
        var k: Int = end
        var pivot: String = ""

        if (end - start >= 1) {
            pivot = arr(start)
            while (k > i) {
                 while (arr(i) <= pivot && i <= end && k > i) {
                     i += 1
                 }
                 while (arr(k) > pivot && k >= start && k >= i) {
                     k -= 1
                 }
                 if (k > i) {
                     swap(arr, i, k)
                 }
             }
            swap(arr, start, k)

            quickSort(arr, start, k - 1)
            quickSort(arr, k + 1, end)
        }
    }

    def swap(arr: Array[String], x: Int, y: Int) {
        var tmp: String = arr(x)
        arr(x) = arr(y)
        arr(y) = tmp
    }

    def printArray(arr: Array[String]) {
        print("[")
        for (i <- 0 to arr.length - 2) {
           print(arr(i) + ", ")
        }
        println(arr(arr.length - 1) + "]")
    }

    def main(args: Array[String]) {
        var arr: Array[String] = for (a <- args) yield a 
        quickSort(arr, 0, arr.length - 1)
        printArray(arr)
    }
}
------------------------------------------------



캄파일> scalac -d . testSort.scala

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

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

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

다음은  대화형 모드(interactive mode)에서 진법 변환(radix conversion)하는 Scala 소스 코드이다.
메뉴는 주메뉴 Command: (S)et radix, (A)bout, (Q)uit or E(x)it
와 부메뉴 SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit
로 구성되어 있으며, 진법 변환의 핵심은 java.lang.Integer 클래스와 java.lang.Long 클래스의 정적 메소드

         Integer.parseInt(String, int); 
         java.lang.Long.toString(long, int);

울 이용하였으며, 지원되는 진법은 2진법에서 36진법 까지이다. 참고로 Java의 Long 타입과 Scala의 Long 타입은 다르므로, 여기서는 java.lang.Long.toString 처럼 Long 타입의 패키지명을 꼭 붙여야 한다. Scala에는 Integer 타입 대신 Int 타입을 쓰므로 Integer.parseInt는 그대로 써도 된다.

Scala 언어의 try ... catch ... finally ... 구문은

        try {
              블럭
        }
        catch {
             case e1 : 예외타입 =>
                  블럭
             case e2 : 예외타입 =>
                  블럭
        }
        finally {
              블럭
        }

1. /*
2.  *  Filename: convertRadix.scala
3.  *            Convert radix in a interactive mode.
4.  *
5.  *  Execute: scala convertRadix.scala
6.  *
7.  *      Date:  2009/03/09
8.  *    Author:  PH Kim   [ pkim (AT) scripts.pe.kr ]
9.  */
11. import java.io._
12. import java.util._
14. def printUsage() {
15.     println("Usage: scala convertRadix.scala")
16.     println("Convert radix in a interactive mode, where the maximum radix is 36.")
17. }
19. def printAbout() {
20.     println("    About: Convert radix in a interactive mode.")
21. }
23. def printMainMenu() {
24.     println("  Command: (S)et radix, (A)bout, (Q)uit or E(x)it")
25. }
27. def printMainPrompt() {
28.     print("  Prompt> ")
29. }
31. def printSubMenu(srcRadix : Int, destRadix : Int) {
32.     println("    Convert Radix_" + srcRadix + " to Radix_" + destRadix)
33.     println("    SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit")
34. }
36. def printSubPrompt() {
37.     print("    Input Value>> ")
38. }
40. def convertRadix(s : String, srcRdx : Int, destRdx : Int) : String = {
41.     var value : Long = 0L
42.     var t = ""
43.     try {
44.         value = Integer.parseInt(s, srcRdx)
45.         t = java.lang.Long.toString(value, destRdx)
46.         return t.toUpperCase()
47.     }
48.     catch {
49.         case e : NumberFormatException =>
50.             println("    Error: " + e.getMessage() + " cantains some invalid character.")
51.             t = "????"
52.             return t
53.     }
54.     finally {
55.       return t.toUpperCase()
56.     }
57. }
59. def doConvert(r : BufferedReader, srcRadix : Int, destRadix : Int) {
60.     var line = ""
61.     var cmd = ""
62.     var srcStr = ""
63.     var destStr = ""
64.     println()
65.     printSubMenu(srcRadix, destRadix)
66.     try {
67.         while (true) {
68.             printSubPrompt()
69.             cmd = r.readLine()
70.             if ("main()".equals(cmd)) {
71.                 return
72.             }
73.             else if ("exit()".equals(cmd) || "quit()".equals(cmd)) {
74.                 System.exit(0)
75.             }
76.             try {
77.                 Integer.parseInt(cmd, srcRadix)
78.                 srcStr = cmd
79.                 destStr = convertRadix(srcStr, srcRadix, destRadix)
80.                 println("        ( " + srcStr + " )_" + srcRadix +  "   --->   ( " + destStr + " )_" + destRadix)
81.                 println()
82.             }
83.             catch {
84.                 case e : NumberFormatException =>
85.                     println("    NumberFormatException: " + e.getMessage())
86.                 case e : IOException =>
87.                     e.printStackTrace()
88.             }
89.         }
90.     }
91. }
93. def doStart() {
94.     var line = ""
95.     var cmd = ""
96.     var srcRadix = 10
97.     var destRadix = 10
98.     var srcStr = ""
99.     var destStr = ""
100.     var onlyOnce : Boolean = true
101.     var r : BufferedReader = new BufferedReader(new InputStreamReader(System.in))
102.     try {
103.         while (true) {
104.             println()
105.             if (onlyOnce) {
106.                 println("  The supported maximum radix is 36.")
107.                 onlyOnce = false
108.             }
109.             printMainMenu()
110.             printMainPrompt()
111.             cmd = r.readLine()
112.             if ("qQxX".contains(cmd) && cmd.length() == 1) {
113.                 System.exit(0)
114.             }
115.             else if ("aA".contains(cmd) && cmd.length() == 1) {
116.                 printAbout()
117.             }
118.             else if ("sS".contains(cmd) && cmd.length() == 1) {
119.                 print("  Input the source and target radices (say, 16 2): ")
120.                 line = r.readLine()
121.                 var st : StringTokenizer = new StringTokenizer(line, " ,\t")
122.                 while (st.countTokens() < 2) {
123.                     print("  Input the source and target radices (say, 16 2): ")
124.                     line = r.readLine()
125.                     st = new StringTokenizer(line, " ,\t");
126.                 }
127.                 srcRadix = Integer.parseInt(st.nextToken())
128.                 destRadix = Integer.parseInt(st.nextToken())
129.                 doConvert(r, srcRadix, destRadix)
130.             }
131.         }
132.     }
133.     catch {
134.         case e: IOException =>
135.             e.printStackTrace()
136.     }
137. }
139. // Begin here
140. if (args.length > 0 && "-h".equals(args(0))) {
141.     printUsage()
142.     System.exit(1)
143. }
145. doStart()

실행> scala convertRadix.scala

  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): 16 2

    Convert Radix_16 to Radix_2
    SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit
    Input Value>> 1FF
        ( 1FF )_16   --->   ( 111111111 )_2

    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): 2 8

    Convert Radix_2 to Radix_8
    SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit
    Input Value>> 1011001
        ( 1011001 )_2   --->   ( 131 )_8

    Input Value>> main()

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





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

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

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

1. /*
2.  *  Filename: testGoldenRatio.scala
3.  *    황금률(즉, 이차방정식 x^2 - x - 1  = 0 의 양의 근)을 계산한다. 
4.  *
5.  *   Execute: scala testGoldenRatio.scala
6.  *
7.  *      Date:  2009/03/09
8.  *    Author:  PH Kim   [ pkim (AT) scripts.pe.kr ]
9.  */
11. def printUsing() {
12.     println("Using: scala testGoldenRatio.scala [-h|-help]")
13.     println("This calculates the value of the golden ratio.")
14. }
16. // 이차방정식 a x^2 + b x + c  = 0 의 근을 구한다.
17. def findQuadraticRoot(a: Double, b: Double, c: Double) : Array[Double] = {
18.     if (a == 0.0) {
19.         throw new RuntimeException("Since the highest coefficient is zero, the given equation is not a quadratic equation.")
20.     }
21.     else if (b*b - 4*a*c < 0.0) {
22.         throw new RuntimeException("Since the discriminant " + (b*b - 4*a*c) + " is negative, the given equation has no real root.")
23.     }
25.     var x1 : Double = (-b + Math.sqrt(b*b - 4*a*c)) / (2.0 * a)
26.     var x2 : Double = (-b - Math.sqrt(b*b - 4*a*c)) / (2.0 * a)
27.     var array : Array[Double] = Array(x1, x2)
28.     return array
29. }
31. // 실행 시작 지점
32. if (args.length > 0 && (args(0).equals("-h") || args(0).equals("-help"))) {
33.     printUsing()
34.     System.exit(1)
35. }
37. var values : Array[Double] = findQuadraticRoot(1.0, -1.0, -1.0)
38. var x1 : Double = values(0)
39. var x2 : Double = values(1)
40. if (x1 >= x2) {
41.     println("The bigger root is " + x1 + ", ")
42.     println("and the less root is " + x2 + ".")
43. }
44. else {
45.     println("The bigger root is " + x2 + ", ")
46.     println("and the less root is " + x1 + ".")
47. }

실행> scala testGoldenRatio.scala
The bigger root is 1.618033988749895,
and the less root is -0.6180339887498949.

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

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

1. /*
2.  *  Filename: testCTime.scala
3.  *
4.  *  Compile: scalac -encoding MS949 testCTime.scala
5.  *  Execute: scala TestCTimeApp
6.  */
8. import java.util._
10. object TestCTimeApp {
12.     var weekNames : Array[String] = Array( "일", "월", "화", "수", "목", "금", "토" )
14.     def main(args: Array[String]) {
15.         def now : Calendar = new GregorianCalendar()
17.         // 1970년 1월 1일 0시 0분 0초부터 시작하여 현재까지의 초
18.         // println("UTC: " + (now.getTime().getTime().intdiv(1000L)) + "초")   // for Groovy
19.         println("UTC: " + (now.getTime().getTime() / 1000L) + "초")
21.         // 현재 시각 표시: 200x년 x월 xx일 (x요일) xx시 xx분 xx초
22.         print(now.get(Calendar.YEAR) + "년 ")
23.         print((1 + now.get(Calendar.MONTH)) + "월 ")
24.         print(now.get(Calendar.DAY_OF_MONTH) +"일 ")
25.         print("(" + weekNames(now.get(Calendar.DAY_OF_WEEK)) + "요일) ")
26.         print(now.get(Calendar.HOUR_OF_DAY) + "시 ")
27.         print(now.get(Calendar.MINUTE) + "분 ")
28.         println(now.get(Calendar.SECOND) + "초")
30.         // 1월 1일은 1, 1월 2일은 2
31.         print("올해 몇 번째 날: " + now.get(Calendar.DAY_OF_YEAR) +", ")
33.         // 0 이면 서머타임 없음
34.         // println("서머타임 적용 여부: " + (now.get(Calendar.DST_OFFSET) == 0 ? "안함" : "함")) // for Groovy
35.         var strTmp = "안함"
36.         if (now.get(Calendar.DST_OFFSET) != 0)
37.             strTmp = "함"
38.         println("서머타임 적용 여부: " + strTmp)
39.     }
40. }

scalac 명령으로 컴파일하고,
생성된 클래스파일(TestCTimeApp.class)을 scala 명령으로 실행한다. 
scala 명령으로 실행할 때는 클래스 파일의 확장자명(.class)을 생략한다.

c -encoding MS949 testCTime.scala
실행> scala TestCTimeApp
UTC: 1236541642초
2009년 3월 9일 (화요일) 4시 47분 22초
올해 몇 번째 날: 68, 서머타임 적용 여부: 안함

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

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

1. /*
2.  *  Filename: testSyntheticDivision.scala
3.  *
4.  *  Purpose:  Find the quotient and remainder when some polynomial is
5.  *            divided by a monic polynomial of the first degree.
6.  *     이 소스는 그루비 소스 testSyntheticDivision.groovy 를
7.  *     스칼라 소스로 변환한 것이다.
8.  *
9.  *  Execute: scala -encoding MS949 testSyntheticDivision.scala -2 1 3 3 1
10.  *
11.  */
13. // 사용법 표시
14. def printUsage() {
15.      println("사용법: scala testSyntheticDivision.scala [수] [피제식의 계수들]")
16.      println("조립제법(synthetic method)에 의한 다항식 나눗셈 결과를 보여준다.")
17. }
19. // 부동소수점수의 표현이 .0 으로 끝나는 경우 이를 잘라낸다.
20. def simplify(v: Double) : String = {
21.     var t : String = "" + v 
22.     if (t.endsWith(".0"))
23.         t = t.substring(0, t.length - 2)
24.     return t
25. }
27. // 부동소수점수의 표현이 .0 으로 끝나는 경우 이를 잘라낸다.
28. // 전체 문자열 표시 너비는 매개변수 width 로 전달받아 처리한다.
29. def simplify(v: Double, width: Int) : String = {
30.     var t : String = "" + v
31.     if (t.endsWith(".0"))
32.         t = t.substring(0, t.length - 2)
33.     var len : Int = t.length
34.     if (len < width)
35.         t = "               ".substring(0, width - len) + t
36.     return t;
37. }
39. // 다항식을 내림차순의 스트링 표현으로 반환
40. def toPolyString(c : Array[Double]) : String = {
41.     var t : String = ""
42.     var sc0 : String = simplify(c(0))
44.     if (c.length > 2) {
45.         if (sc0 == "1")
46.             t += "x^" + (c.length-1)
47.         else if (sc0 == "-1")
48.             t += "-x^" + (c.length-1)
49.         else
50.             t += sc0 + " x^" + (c.length-1)
51.     }
52.     else if (c.length == 2) {
53.         if (sc0 == "1")
54.             t += "x"
55.         else if (sc0 == "-1")
56.             t += "-x"
57.         else
58.             t += sc0 + " x"
59.     }
60.     else if (c.length == 1) {
61.         t += sc0
62.     }
64.     for (i <- List.range(1, c.length)) {
65.         def k = c.length - 1 - i
66.         def sc = simplify(c(i))
67.         if (k > 1) {
68.             if (c(i) > 0.0) {
69.                 if (sc == "1")
70.                     t += " + " + "x^" + k
71.                 else
72.                     t += " + " + sc + " x^" + k
73.             }
74.             else if (c(i) < 0.0) {
75.                 if (sc == "-1")
76.                     t += " - " + "x^" + k
77.                 else
78.                     t += " - " + simplify(Math.abs((i))) + " x^" + k
79.             }
80.         }
81.         else if (k == 1) {
82.             if (c(i) > 0.0) {
83.                 if (sc == "1")
84.                     t += " + " + "x"
85.                 else
86.                     t += " + " + sc + " x"
87.             }
88.             else if (c(i) < 0.0) {
89.                 if (sc == "-1")
90.                     t += " - " + "x"
91.                 else
92.                     t += " - " + simplify(Math.abs(c(i))) + " x"
93.             }
94.         }
95.         else if (k == 0) {
96.             if (c(i) > 0.0) {
97.                 t += " + " + sc
98.             }
99.             else if (c(i) < 0.0)
100.                 t += " - " + simplify(Math.abs(c(i)))
101.         }
102.     }
103.     return t
104. }
106. // 다항식 나눗셈 결과를
107. //     (피제식) = (제식)(몫) + (나마지)
108. // 형태로 출력
109. def printDivisionResult(a : Double, c : Array[Double], b : Array[Double]) {
110.     print("  " + toPolyString(c))
111.     println()
113.     print("    = ( " + toPolyString( Array(1.0, -a)  ) + " )")
114.     var tmp : Array[Double] = new Array[Double](b.length - 1)
115.     for (i <- List.range(0, tmp.length)) {
116.         tmp(i) = b(i)
117.     }
118.     print("( " + toPolyString(tmp) + " )")
119.     var r : Double = b(b.length - 1)
120.     if (r > 0.0)
121.         print(" + " + simplify(r))
122.     else if (r < 0.0)
123.         print(" - " + simplify(Math.abs(r)))
124.     println()
125. }
127. // 조립제법 계산표 출력 함수
128. def printSyntheticTable(a : Double, c : Array[Double], s : Array[Double], q : Array[Double]) {
129.     print("       | ")
130.     print(simplify(c(0), 6))
131.     for (i <- List.range(1, c.length)) {
132.         print("  " + simplify(c(i), 6))
133.     }
134.     println()
135.     print(simplify(a, 6) + " | ")
136.     print("        ")
137.     print(simplify(s(1), 6))
138.     for (i <- List.range(2, s.length)) {
139.         print("  " + simplify(s(i), 6))
140.     }
141.     println()
143.     print("       |-")
144.     for (i <- List.range(0, q.length)) {
145.         print("--------")
146.     }
147.     println()
149.     print("         ")
150.     print(simplify(q(0), 6))
151.     for (i <- List.range(1, q.length)) {
152.         print("  " + simplify(q(i), 6))
153.     }
154.     println()
155. }
157. // 실행 시작 지점
158. if (args.length < 3) {
159.     printUsage()
160.     System.exit(1)
161. }
163. var a : Double = args(0).toDouble
164. var c : Array[double] = new Array[Double](args.length - 1)
165. var s : Array[double] = new Array[Double](c.length)
166. var b : Array[double] = new Array[Double](c.length)
167. for (i <- List.range(0, c.length)) {
168.     c(i) = args(i + 1).toDouble
169. }
171. s(0) = 0.0
172. b(0) = c(0)
173. for (i <- List.range(1, c.length)) {
174.     s(i) = b(i-1)*a
175.     b(i) = c(i) + s(i)
176. }
178. print("몫의 계수는 ")
179. for (i <- List.range(0, b.length - 2)) {
180.     print(simplify(b(i)) + ", " )
181. }
183. print(simplify(b(b.length - 2)))
184. println(" 이고, 나머지는 " + simplify(b(b.length - 1)) + " 이다.")
185. println()
187. printSyntheticTable(a, c, s, b)
188. println()
190. printDivisionResult(a, c, b)

scala 명령으로 아래와 같이 실행하여 보았다.


실행> scala -encoding MS949 testSyntheticDivision.scala 1 2 3 4 5
몫의 계수는 2, 5, 9 이고, 나머지는 14 이다.

       |      2       3       4       5
     1 |              2       5       9
       |---------------------------------
              2       5       9      14

  2 x^3 + 3 x^2 + 4 x + 5
    = ( x - 1 )( 2 x^2 + 5 x + 9 ) + 14

다음은 Groovy 소스 코드를 Scala 소스 코드로 변경한 것이다.

Scala 언어는 Java 언어 처럼 타입을 엄격히 지키는 언어이다.
하지만 Scala 언어는 ML, Haskell 언어 처럼 함수 프로그래밍을 적극 도입한 언어이다.

 

1. /*
2.  *  Filename: testForFor.scala
3.  *
4.  *  Execute:  scala testForFor.scala
5.  *
6.  *  Date:  2008. 5. 18.
7.  */
9. def getDan(dan: Int) : Array[String] = {
10.     var t : Array[String] = new Array[String](20)
11.     var sa, sb, sval = ""
12.     for (j <- 0 to 18) {
13.         sa = "" + dan
14.         if (sa.length < 2)
15.             sa = " " + sa
16.         sb = "" + (j + 1)
17.         if (sb.length < 2)
18.             sb = " " + sb
19.         sval = "" + (dan*(j + 1))
20.         if (sval.length < 2)
21.             sval = "  " + sval
22.         else if (sval.length < 3)
23.             sval = " " + sval
24.         t(j) = sa + " x " + sb + " = " + sval
25.     }
26.     return t
27. }
29. // 19단표를 모두 80컬럼 컨솔에 출력한다.
30. def printAllNineteenDan() {
31.     var arr : Array[Array[String]] = new Array[Array[String]](18)
32.     for (i <- 2 to 19) {
33.         arr(i - 2) = getDan(i)
34.     }
36.     // 아래는 String의 배열을 사용하는 Scala 코드이다.
37.     var d = List( 2, 7, 11, 16 )      // 각 줄단위 블럭의 첫단
38.     var counter = List( 5, 4, 5, 4 )  // 각 줄단위 블럭에 속한 단의 개수
39.     var lines = new Array[String](19)
41.     for (k <- List.range(0, d.length)) {
42.         // 80 바이트 길이의 한 줄씩 완성
43.         for (i <- List.range(0, 19)) {
44.             lines(i) = arr(d(k)-2)(i)
45.             for (j <- List.range(1, counter(k))) {
46.                 lines(i) = lines(i) + "   " +  arr(d(k)-2+j)(i)
47.             }
48.         }
50.         // 8-바이트 길이의 한 줄씩 출력
51.         for (i <- List.range(0, 19)) {
52.             println(lines(i))
53.         }
54.         println()
55.     }
56. }
58. printAllNineteenDan()

실행> scala -encoding MS949 testForFor.scala

 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