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

다항식 p(x) 를 1차 다항식 x - a 로 나눌 때의 몫과 나머지를 구하는 조립제법을
C 언어로 구현해 보았다. 조립제법은 일명 Horner의 방법이라고도 불리우는데, 이는
x = a 에서 다항식 p(x)의 값 p(a)을 계산하는 가장 빠른 알고리즘이기도 하다.

         p(x) = (x - a)q(x) + r

여기서 r은 나머지이며 r = p(a) 이다. 또 q(x)는 몫이다.

[참고]
    * 온라인으로 조립제법 표 만들기 손으로 계산하는 조립제법 표 
    * 온라인으로 구하는 다항식의 도함수: 조립제법을 이용한 다항식의 도함수


아래의 소스파일은 Ch를 사용하면 컴파일하지 않고 수정 없이 그대로 실행된다.
(실행 예:  ch testSyntheticDivision.c 1 2 3 4 5  )

1. /*
2.  *  Filename: testSyntheticDivision.c
3.  *
4.  *  Purpose:  Find the quotient and remainder when some polynomial is
5.  *            divided by a monic polynomial of the first degree.
6.  *
7.  *  Compile:  cl testSyntheticDivision.c
8.  *
9.  *  Execute:  testSyntheticDivision -2 1 3 3 1
10.  */
12. #include <stdio.h>
13. #include <string.h>
14. #include <math.h>
15. #include <memory.h>
18. void print(char str[]) {
19.     printf("%s", str);
20. }
22. void println(char str[]) {
23.     printf("%s\n", str);
24. }
26. // 사용법 표시
27. void printUsage() {
28.      println("사용법: testSyntheticDivision [수] [피제식의 계수들]");
29.      println("조립제법(synthetic method)에 의한 다항식 나눗셈 결과를 보여준다.");
30. }
32. // 부동소수점수의 표현이 .0 으로 끝나는 경우 이를 잘라낸다.
33. // 전체 문자열 표시 너비는 매개변수 width 로 전달받아 처리한다.
34. char *simplify(double v, int width) {
35.     int n, len;
36.     static char t[] = "                               ";
37.     char tmp[] = "                               ";
38.     sprintf(t, "%g", v);
39.     n = strlen(t);
40.     if ((n > 2) && (t[n - 2] == '.') && (t[n - 1] == '0'))
41.         t[n-2] = '\0';
42.     len = strlen(t);
43.     strcpy(tmp, t);
44.     if (len < width) {
45.         strncpy(t, "               ", width - len);
46.         t[width - len] = '\0';
47.         strcat(t, tmp);
48.     }
49.     return (char *) t;
50. }
52. // 다항식을 내림차순의 문자열로로 반환하는 함수
53. // 반환된 문자열은 동적 메모리에 존재하므로.
54. // 사용 후 반드시 해제(free)하여야 한다.
55. char *toPolyString(double c[], int size) {
56.     int SIZE = size;
57.     int i;
58.     static char t[300];
59.     char tmp[80];
60.     char *pc = simplify(c[0], -1);
61.     char *pci;
62.     if (SIZE > 2) {
63.         if (strlen(pc) == 1 && pc[0] == '1')
64.             sprintf(t,  "x^%d", SIZE - 1);
65.         else if (strlen(pc) == 2 && pc[0] == '-' && pc[1] == '1')
66.             sprintf(t,  "-x^%d", SIZE - 1);
67.         else
68.             sprintf(t,  "%s x^%d", simplify(c[0], -1), SIZE - 1);
69.     }
70.     else if (SIZE == 2) {
71.         if (strlen(pc) == 1 && pc[0] == '1')
72.             strcpy(t,  "x");
73.         else if (strlen(pc) == 2 && pc[0] == '-' && pc[1] == '1')
74.             strcpy(t,  "-x");
75.         else
76.             sprintf(t,  "%s x", simplify(c[0], -1));
77.     }
78.     else if (SIZE == 1) {
79.         sprintf(t,  "%s", simplify(c[0], -1));
80.     }
82.     for (i = 1; i < SIZE; i++) {
83.         pci = simplify(c[i], -1);
84.         if (SIZE - 1 - i > 1) {
85.             if (c[i] > 0.0) {
86.                 if (strlen(pci) == 1 && pci[0] == '1') {
87.                     sprintf(tmp,  " + x^%d", SIZE - 1 - i);
88.                     strcat(t, tmp);
89.                 }
90.                 else {
91.                     sprintf(tmp,  " + %s x^%d", simplify(c[i], -1), SIZE - 1 - i);
92.                     strcat(t, tmp);
93.                 }
94.             }
95.             else if (c[i] < 0.0) {
96.                 if (strlen(pci) == 2 && pci[0] == '-' && pci[1] == '1') {
97.                     sprintf(tmp,  " - x^%d", SIZE - 1 - i);
98.                     strcat(t, tmp);
99.                 }
100.                 else {
101.                     sprintf(tmp,  " - %s x^%d", simplify(fabs(c[i]), -1), SIZE - 1 - i);
102.                     strcat(t, tmp);
103.                 }
104.             }
105.         }
106.         else if (SIZE - 1 - i == 1) {
107.             if (c[i] > 0.0) {
108.                 if (strlen(pci) == 1 && pci[0] == '1') {
109.                     strcat(t, " + x");
110.                 }
111.                 else {
112.                     sprintf(tmp,  " + %s x", simplify(c[i], -1));
113.                     strcat(t, tmp);
114.                 }
115.             }
116.             else if (c[i] < 0.0) {
117.                 if (strlen(pci) == 2 && pci[0] == '-' && pci[1] == '1') {
118.                     strcat(t, " - x");
119.                 }
120.                 else {
121.                     sprintf(tmp,  " - %s x", simplify(fabs(c[i]), -1));
122.                     strcat(t, tmp);
123.                 }
124.             }
125.         }
126.         else if (SIZE - 1 - i == 0) {
127.             if (c[i] > 0.0) {
128.                 sprintf(tmp,  " + %s", simplify(c[i], -1));
129.                 strcat(t, tmp);
130.             }
131.             else if (c[i] < 0.0) {
132.                 sprintf(tmp,  " - %s", simplify(fabs(c[i]), -1));
133.                 strcat(t, tmp);
134.             }
135.         }
136.     }
137.     return (char *) t;
138. }
140. // 다향식 나눗셈 결과를
141. //     (피제식) = (제식)(몫) + (나마지)
142. // 형태로 출력
143. void printDivisionResult(double a, double c[], double b[], int size) {
144.     int SIZE = size;
145.     int i;
146.     double *pTmpPoly;
147.     double r;
148.     double monic[] = { 1.0, 0.0 };
150.     print("  ");
151.     print(toPolyString(c, SIZE));
152.     println("");
154.     print("    = ( ");
155.     monic[1] = -a;
156.     print(toPolyString(  monic, 2 ));
157.     print(" )");
159.     pTmpPoly = (double *)  calloc(SIZE - 1, sizeof(double));
160.     for (i = 0; i < SIZE - 1; i++) {
161.         pTmpPoly[i] = b[i];
162.     }
163.     print("( ");
164.     print(toPolyString(pTmpPoly, SIZE - 1));
165.     print(" )");
166.     free(pTmpPoly);
168.     r = b[SIZE - 1];
169.     if (r > 0.0) {
170.         print(" + ");
171.         print(simplify(r, -1));
172.     }
173.     else if (r < 0.0) {
174.         print(" - ");
175.         print(simplify(fabs(r), -1));
176.     }
177.     println("");
178. }
180. // 조립제법 계산표 출력 함수
181. void printSyntheticTable(double a, double c[], double s[], double q[], int size) {
182.     int SIZE = size;
183.     int i;
184.     print("       | ");
185.     print(simplify(c[0], 6));
186.     for (i = 1; i < SIZE; i++) {
187.         print("  ");
188.         print(simplify(c[i], 6));
189.     }
190.     println("");
192.     print(simplify(a, 6));
193.     print(" | ");
194.     print("        ");
195.     print(simplify(s[1], 6));
196.     for (i = 2; i < SIZE; i++) {
197.         print("  ");
198.         print(simplify(s[i], 6));
199.     }
200.     println("");
202.     print("       |-");
203.     for (i = 0; i < SIZE; i++) {
204.         print("--------");
205.     }
206.     println("");
208.     print("         ");
209.     print(simplify(q[0], 6));
210.     for (i = 1; i < SIZE; i++) {
211.         print("  ");
212.         print(simplify(q[i], 6));
213.     }
214.     println("");
215. }
218. // C/C++/Ch 언어의 실행 시작 지점
219. int main(int argc, char *argv[]) {
220.     int i;
221.     int SIZE = argc - 2;
222.     double a, c[15], s[15], b[15];
223.     if (argc < 4) {
224.         printUsage();
225.         exit(1);
226.     }
228.     //////////////////////////////////////////////////////
229.     // 피제식은 c_0 x^n +  c_1 x^(n -1) + ... + c_n
230.     // 제식은 x -  a
231.     a = atof(argv[1]);
233.     for (i = 0; i < SIZE; i++) {
234.         c[i] = atof(argv[i + 2]);
235.     }
237.     //////////////////////////////////////////////////////
238.     // 조립제법의 주요 부분
239.     s[0] = 0.0;
240.     b[0] = c[0];
241.     for (i = 1; i < SIZE; i++) {
242.         s[i] = b[i-1]*a;
243.         b[i] = c[i] + s[i];
244.     }
246.     //////////////////////////////////////////////////////
247.     // 몫의 계수와 나머지를 출력한다.
248.     print("몫의 계수는 ");
249.     for (i = 0; i < SIZE - 2; i++) {
250.         print(simplify(b[i], -1));
251.         print(", ");
252.     }
253.     print(simplify(b[SIZE - 2], -1));
254.     print(" 이고, 나머지는 ");
255.     print(simplify(b[SIZE - 1], -1));
256.     println(" 이다.");
257.     println("");
259.     //////////////////////////////////////////////////////
260.     // 조립제법 표를 출력한다.
261.     printSyntheticTable(a, c, s, b, SIZE);
262.     println("");
264.     //////////////////////////////////////////////////////
265.     // (피제식) = (제식) x (몫) + (나머지)
266.     printDivisionResult(a, c, b, SIZE);
267.     return 0;
268. }

컴파일> cl testSyntheticDivision.c

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

 

다항식 p(x) 를 1차 다항식 x - a 로 나눌 때의 몫과 나머지를 구하는 조립제법을
Java 언어로 구현해 보았다. 조립제법은 일명 Horner의 방법이라고도 불리우는데, 이는
x = a 에서 다항식 p(x)의 값 p(a)을 계산하는 가장 빠른 알고리즘이기도 하다.

         p(x) = (x - a)q(x) + r

여기서 r은 나머지이며 r = p(a) 이다. 또 q(x)는 몫이다.

[참고]
    * 온라인으로 조립제법 표 만들기 손으로 계산하는 조립제법 표 
    * 온라인으로 구하는 다항식의 도함수: 조립제법을 이용한 다항식의 도함수


아래의 소스파일은 Ruby용 소스파일 testSyntheticDivision.rb 를 Lua용으로 수정한 것이다.

1. --[[
2.   Filename: testSyntheticDivision.lua
4.   Purpose:  Find the quotient and remainder when some polynomial is
5.             divided by a monic polynomial of the first degree.
7.   Execute:  lua testSyntheticDivision.lua -2 1 3 3 1
8. --]]
10. -- 사용법 표시
11. function printUsage()
12.     print("사용법: lua testSyntheticDivision.lua [수] [피제식의 계수들]")
13.     print("조립제법(synthetic method)에 의한 다항식 나눗셈 결과를 보여준다.")
14. end   
16. -- 부동소수점수의 표현이 .0 으로 끝나는 경우 이를 잘라낸다.
17. -- 전체 문자열 표시 너비는 매개변수 width 로 전달받아 처리한다.
18. function simplify(v, width)
19.     t = "" .. v
20.     tlen = string.len(t)
21.     if string.sub(t, tlen-2) == ".0" then
22.         t = string.sub(t, 0, tlen-2)
23.     end
24.     if width ~= nil then
25.         if tlen < width then
26.             t = string.sub("              ", 0, width - tlen) .. t
27.         end
28.     end
29.     return t
30. end
32. -- 다항식을 내림차순의 스트링 표현으로 반환
33. function toPolyString(c)
34.     local t = ""
35.     sc0 = simplify(c[1], null)
36.     if #c > 2 then
37.         if sc0 == "1" then
38.             t = t .. "x^" .. (#c-1)
39.         elseif sc0 == "-1" then
40.             t = t .. "-x^" .. (#c-1)
41.         else
42.             t = t .. sc0 .. " x^" .. (#c-1)
43.         end
44.     elseif #c == 2 then
45.         if sc0 == "1" then
46.             t = t .. "x"
47.         elseif sc0 == "-1" then
48.             t = t .. "-x"
49.         else
50.             t = t .. sc0 .. " x"
51.         end
52.     elseif #c == 1 then
53.         t = t .. sc0
54.     end
56.     for i = 2, #c do
57.         k = #c - i
58.         sc = simplify(c[i], nil)
59.         if k > 1 then
60.             if c[i] > 0.0 then
61.                 if sc == "1" then
62.                     t = t .. " + " .. "x^" .. k
63.                 else
64.                     t = t .. " + " .. sc .. " x^" .. k
65.                 end
66.             elseif c[i] < 0.0 then
67.                 if sc == "-1" then
68.                     t = t .. " - " .. "x^" .. k
69.                 else
70.                     t = t .. " - " .. simplify(math.abs(c[i]), nil) .. " x^" .. k
71.                 end
72.             end
73.         elseif k == 1 then
74.             if c[i] > 0.0 then
75.                 if sc == "1" then
76.                     t = t .. " + " .. "x"
77.                 else
78.                     t = t .. " + " .. sc .. " x"
79.                 end
80.             elseif c[i] < 0.0 then
81.                 if sc == "-1" then
82.                     t = t .. " - " .. "x"
83.                 else
84.                     t = t .. " - " .. simplify(math.abs(c[i]), null) .. " x"
85.                 end
86.             end
87.         elseif k == 0 then
88.             if c[i] > 0.0 then
89.                 t = t .. " + " .. sc
90.             elseif c[i] < 0.0 then
91.                 t = t .. " - " .. simplify(math.abs(c[i]), null)
92.             end
93.         end
94.     end
95.     return t
96. end
98. -- 다향식 나눗셈 결과를
99. --     (피제식) = (제식)(몫) + (나마지)
100. -- 형태로 출력
101. function printDivisionResult(a, c, b)
102.     local strLine = "  " .. toPolyString(c)
103.     io.write( strLine .. "\n")
104.     strLine = "    = ( " .. toPolyString( { 1.0, -a } ) .. " )"
105.     tmp = { }
106.     for i = 1, #b - 1 do
107.         tmp[i] = b[i]
108.     end
110.     strLine = strLine .. "( " .. toPolyString(tmp) .. " )"
111.     r = b[#b]
112.     if r > 0.0 then
113.         strLine = strLine .. " + " .. simplify(r, nil)
114.     elseif r < 0.0 then
115.         strLine = strLine .. " - " .. simplify(math.abs(r), nil)
116.     end
117.     io.write( strLine .. "\n" )
118. end
120. -- 조립제법 계산표 출력 함수
121. function printSyntheticTable(a, c, s, q)
122.     strLine = "       | "
123.     strLine = strLine .. simplify(c[1], 6)
124.     for i = 2, #c do
125.         strLine = strLine .. "  " .. simplify(c[i], 6)
126.     end
127.     io.write( strLine .. "\n" )
129.     strLine = simplify(a, 6) ..  " |"
130.     strLine = strLine .. "         "
131.     strLine = strLine .. simplify(s[2], 6)
132.     for i = 3, #s do
133.         strLine = strLine .. "  " .. simplify(s[i], 6)
134.     end
135.     io.write( strLine .. "\n" )
137.     strLine = "       |"
138.     for i = 1, #q do
139.         strLine = strLine .. "--------"
140.     end
141.     io.write( strLine .. "\n" )
143.     strLine = "         "
144.     strLine = strLine .. simplify(q[1], 6)
145.     for i = 2, #q do
146.         strLine = strLine .. "  " .. simplify(q[i], 6)
147.     end
148.     io.write( strLine .. "\n" )
149. end
151. -- 실행 시작 지점
152. if #arg < 3 then
153.     printUsage()
154.     os.exit(1)
155. end
157. -- 피제식은 c_0 x^n +  c_1 x^(n -1) + ... + c_n
158. -- 제식은 x -  a
159. a = arg[1]
160. c = { }
161. s = { }
162. b = { }
164. for i = 1, #arg-1 do
165.     c[i] = tonumber(arg[i + 1])
166. end
168. -- 조립제법의 주요 부분
169. s[1] = 0.0
170. b[1] = c[1]
171. for i = 2, #c do
172.     s[i] = b[i-1]*a
173.     b[i] = c[i] + s[i]
174. end
176. -- 몫의 계수와 나머지를 출력한다.
177. io.write("몫의 계수는 ")
178. for i = 1, #b-1 do
179.     io.write(simplify(b[i], nil) .. ", ");
180. end
181. io.write(simplify(b[#b], nil) .. " ")
182. io.write("이고, 나머지는 " .. simplify(b[#b], nil) .. " 이다." .. "\n")
183. io.write("\n")
185. -- 조립제법 표를 출력한다.
186. printSyntheticTable(a, c, s, b)
187. io.write("\n")
189. -- (피제식) = (제식) x (몫) + (나머지)
190. printDivisionResult(a, c, b)

실행> lua testSyntheticDivision.lua 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

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

다항식 p(x) 를 1차 다항식 x - a 로 나눌 때의 몫과 나머지를 구하는 조립제법을
Ruby 언어로 구현해 보았다. 조립제법은 일명 Horner의 방법이라고도 불리우는데, 이는
x = a 에서 다항식 p(x)의 값 p(a)을 계산하는 가장 빠른 알고리즘이기도 하다.

         p(x) = (x - a)q(x) + r

여기서 r은 나머지이며 r = p(a) 이다. 또 q(x)는 몫이다.

[참고]
    * 온라인으로 조립제법 표 만들기 손으로 계산하는 조립제법 표 
    * 온라인으로 구하는 다항식의 도함수: 조립제법을 이용한 다항식의 도함수


아래의 소스파일은 Python용 소스파일 testSyntheticDivision.py 를 Ruby용으로 수정한 것이다.

ruby 대신 jruby 로도 수정 없이 그대로 실행된다.

1. =begin
2.   Filename: testSyntheticDivision.rb
4.   Purpose:  Find the quotient and remainder when some polynomial is
5.             divided by a monic polynomial of the first degree.
7.   Execute:  ruby testSyntheticDivision.rb -2 1 3 3 1
8.         Or  jruby testSyntheticDivision.rb -2 1 3 3 1
9. =end
11. # 사용법 표시
12. def printUsage()
13.     print("사용법: ruby testSyntheticDivision.rb [수] [피제식의 계수들]" + "\n")
14.     print("조립제법(synthetic method)에 의한 다항식 나눗셈 결과를 보여준다." + "\n")
15. end
17. # 부동소수점수의 표현이 .0 으로 끝나는 경우 이를 잘라낸다.
18. # 전체 문자열 표시 너비는 매개변수 width 로 전달받아 처리한다.
19. def simplify(v, width)
20.     t = "%d" % v
21.     tlen = t.length
22.     if t[(tlen-2)..(tlen-1)] == ".0"
23.         t = t[0..(tlen-2)]
24.     end
25.     if width != nil
26.         if tlen < width
27.             t = "              "[0...(width - tlen)] + t
28.         end
29.     end
30.     return t
31. end
33. # 다항식을 내림차순의 스트링 표현으로 반환
34. def toPolyString(c)
35.     t = ""
36.     sc0 = simplify(c[0], nil)
37.     if c.length > 2
38.         if sc0 == "1"
39.             t += "x^%d" % (c.length-1)
40.         elsif sc0 == "-1"
41.             t += "-x^%d" % (c.length-1)
42.         else
43.             t += sc0 + " x^%d" % (c.length-1)
44.         end
45.     elsif c.length == 2
46.         if sc0 == "1"
47.             t += "x"
48.         elsif sc0 == "-1"
49.             t += "-x"
50.         else
51.             t += sc0 + " x"
52.         end
53.     elsif c.length == 1
54.         t += sc0
55.     end
57.     for i in 1...c.length do
58.         k = c.length - 1 - i
59.         sc = simplify(c[i], nil)
60.         if k > 1
61.             if c[i] > 0.0
62.                 if sc == "1"
63.                     t += " + " + "x^" + k
64.                 else
65.                     t += " + " + sc + " x^%d" % k
66.                 end
67.             elsif c[i] < 0.0
68.                 if sc == "-1"
69.                     t += " - " + "x^" + k
70.                 else
71.                     t += " - " + simplify(c[i].abs, nil) + " x^%d" % k
72.                 end
73.             end
74.         elsif k == 1
75.             if c[i] > 0.0
76.                 if sc == "1"
77.                     t += " + " + "x"
78.                 else
79.                     t += " + " + sc + " x"
80.                 end
81.             elsif c[i] < 0.0
82.                 if sc == "-1"
83.                     t += " - " + "x"
84.                 else
85.                     t += " - " + simplify(c[i].abs, nil) + " x"
86.                 end
87.             end
88.         elsif k == 0
89.             if c[i] > 0.0
90.                 t += " + " + sc
91.             elsif c[i] < 0.0
92.                 t += " - " + simplify(c[i].abs, nil)
93.             end
94.         end
95.     end
96.     return t
97. end
99. # 다향식 나눗셈 결과를
100. #     (피제식) = (제식)(몫) + (나마지)
101. # 형태로 출력
102. def printDivisionResult(a, c, b)
103.     strLine = "  " + toPolyString(c)
104.     print( strLine + "\n")
106.     strLine = "    = ( " + toPolyString( [1.0, -a] ) + " )"
107.     tmp = [0.0] * (b.length - 1)
108.     for i in 0...tmp.length do
109.         tmp[i] = b[i]
110.     end
111.     strLine += "( " + toPolyString(tmp) + " )"
112.     r = b[b.length - 1]
113.     if r > 0.0
114.         strLine += " + " + simplify(r, nil)
115.     elsif r < 0.0
116.         strLine += " - " + simplify(r.abs, nil)
117.     end
118.     print( strLine + "\n" )
119. end
121. # 조립제법 계산표 출력 함수
122. def printSyntheticTable(a, c, s, q)
123.     strLine = "       | "
124.     strLine += simplify(c[0], 6)
125.     for i in 1...c.length do
126.         strLine += "  " + simplify(c[i], 6)
127.     end
128.     print( strLine + "\n" )
130.     strLine = simplify(a, 6) + " |"
131.     strLine += "         "
132.     strLine += simplify(s[1], 6)
133.     for i in 2...s.length do
134.         strLine += "  " + simplify(s[i], 6)
135.     end
136.     print( strLine + "\n" )
138.     strLine = "       |"
139.     for i in 0...q.length do
140.         strLine += "--------"
141.     end
142.     print( strLine + "\n" )
144.     strLine = "         "
145.     strLine += simplify(q[0], 6)
146.     for i in 1...q.length do
147.         strLine += "  " + simplify(q[i], 6)
148.     end
149.     print( strLine + "\n" )
150. end
153. # 실행 시작 지점
154. if ARGV.length < 2
155.     printUsage()
156.     exit(1)
157. end
159. ######################################################
160. # 피제식은 c_0 x^n +  c_1 x^(n -1) + ... + c_n
161. # 제식은 x -  a
162. a = ARGV[0].to_f
163. c = [0.0]*(ARGV.length - 1)
164. s = [0.0]*(+ARGV.length - 1)
165. b = [0.0]*(ARGV.length - 1)
167. for i in 0...c.length do
168.     c[i] = ARGV[i + 1].to_f
169. end
171. ######################################################
172. # 조립제법의 주요 부분
173. s[0] = 0.0
174. b[0] = c[0]
175. for i in 1...c.length do
176.     s[i] = b[i-1]*a
177.     b[i] = c[i] + s[i]
178. end
180. ######################################################
181. # 몫의 계수와 나머지를 출력한다.
182. print("몫의 계수는 ")
183. for i in 0...(b.length - 2) do
184.     print(simplify(b[i], nil) + ", " )
185. end
186. print(simplify(b[b.length - 2], nil) + " ")
187. print("이고, 나머지는 " + simplify(b[b.length - 1], nil) + " 이다." + "\n")
188. print("\n")
190. ######################################################
191. # 조립제법 표를 출력한다.
192. printSyntheticTable(a, c, s, b)
193. print("\n")
195. ######################################################
196. # (피제식) = (제식) x (몫) + (나머지)
197. printDivisionResult(a, c, b)

실행> ruby testSyntheticDivision.rb 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

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