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

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

1. # -*- encoding: ms949 -*-
3. #  Filename: testCTime.py
4. #  Execute: python testCTime.py
6. from time import *
8. # Python case
9. weekNames = [ "월", "화", "수", "목", "금", "토", "일" ]  
11. utctime = time()
12. cNow = localtime(utctime)
14. # 1970년 1월 1일 0시 0분 0초부터 시작하여 현재까지의 초
15. print("UTC: %d초" % int(utctime))
17. # 현재 시각 표시: 200x년 x월 xx일 (x요일) xx시 xx분 xx초
18. print("%d년 %d월 %d일 (%s요일) %d시 %d분 %d초" % (cNow.tm_year, cNow.tm_mon, cNow.tm_mday, weekNames[cNow.tm_wday], cNow.tm_hour, cNow.tm_min, cNow.tm_sec) )
20. # 1월 1일은 1, 1월 2일은 2
21. # localtime().tz_isdat == 0 이면, 서머타임 없음
22. # localtime().tz_isdat == 1 이면, 서머타임 있음
23. if cNow.tm_isdst == 0:
24.     strIsDST = "안함"
25. else:
26.     strIsDST = "함"
27. print("올해 몇 번째 날: %d, 서머타임 적용 여부: %s" % (cNow.tm_yday, strIsDST))

실행> python testCTime.py
UTC: 1206324568
2008년 3월 24일 (월요일) 11시 9분 28초
올해 몇 번째 날: 84, 서머타임 적용 여부: 안함

실행> jython testCTime.py
UTC: 1206324572
2008년 3월 24일 (월요일) 11시 9분 32초
올해 몇 번째 날: 84, 서머타임 적용 여부: 안함



다음은 IronPython을 위해 새로 작성된 소스 코드이다.
인코딩에 ms949와 MS949는 에러가 생기고, cp949, CP949, euc-kr, EUC-KR 만 인식된다. 
날짜와 시간 관련 처리는 닷넷(C#)의 것을 따랐다.

1. # -*- encoding: cp949 -*-
3. #  Filename: testCTime.py
4. #  Execute: ipy testCTime.py
6. from System import *
8. # Python/Jython/IronPython case
9. weekNames = [ "월", "화", "수", "목", "금", "토", "일" ]  
11. cNow = DateTime.Now
12. StartOfEpoch = DateTime(1970, 1, 1)
14. # 1970년 1월 1일 0시 0분 0초부터 시작하여 현재까지의 초
15. print "UTC: %d초" % (Convert.ToInt64((DateTime.UtcNow - StartOfEpoch).TotalMilliseconds)/1000L)
17. # 현재 시각 표시: 200x년 x월 xx일 (x요일) xx시 xx분 xx초
18. print("%d년 %d월 %d일 (%s요일) %d시 %d분 %d초" % (cNow.Year, cNow.Month, cNow.Day, weekNames[int(cNow.DayOfWeek)], cNow.Hour, cNow.Minute, cNow.Second) )
20. # cNow.IsDaylightSavingTime() == False 이면, 서머타임 없음
21. # cNow.IsDaylightSavingTime() == True 이면, 서머타임 있음
22. if cNow.IsDaylightSavingTime():
23.     strIsDST = "함"
24. else:
25.     strIsDST = "안함"
27. print("올해 몇 번째 날: %d , 서머타임 적용 여부: %s" % (cNow.DayOfYear, strIsDST))

실행> ipy testCTime.py
UTC: 1239235489초
2009년 4월 9일 (금요일) 9시 4분 49초
올해 몇 번째 날: 99 , 서머타임 적용 여부: 안함




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

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

1. /*
2.  *  Filename: testCTime.groovy
3.  *
4.  *  Execute: groovy testCTime.groovy
5.  */
7. public class TestCTimeApp {
9.    static def weekNames = [ "일", "월", "화", "수", "목", "금", "토" ].asImmutable()
11.    public static void main(String[] args) {
12.         Calendar now = new GregorianCalendar()
14.         // 1970년 1월 1일 0시 0분 0초부터 시작하여 현재까지의 초
15.         println("UTC: " + (now.getTime().getTime().intdiv(1000L)) + "초")
17.         // 현재 시각 표시: 200x년 x월 xx일 (x요일) xx시 xx분 xx초
18.         print(now.get(Calendar.YEAR) + "년 ")
19.         print((1 + now.get(Calendar.MONTH)) + "월 ")
20.         print(now.get(Calendar.DAY_OF_MONTH) +"일 ")
21.         print("(" + weekNames[now.get(Calendar.DAY_OF_WEEK)] + "요일) ")
22.         print(now.get(Calendar.HOUR_OF_DAY) + "시 ")
23.         print(now.get(Calendar.MINUTE) + "분 ")
24.         println(now.get(Calendar.SECOND) + "초")
26.         // 1월 1일은 1, 1월 2일은 2
27.         print("올해 몇 번째 날: " + now.get(Calendar.DAY_OF_YEAR) +", ")
29.         // 0 이면 서머타임 없음
30.         println("서머타임 적용 여부: " + (now.get(Calendar.DST_OFFSET) == 0 ? "안함" : "함"))
31.     }
32. }

실행> groovy testCTime.groovy
UTC: 1206324111초
2008년 3월 24일 (화요일) 11시 1분 51초
올해 몇 번째 날: 84, 서머타임 적용 여부: 안함





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

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

1. /*
2.  *  Filename: TestCTimeApp.java
3.  *
4.  *  Compile: javac -d . TestCTimeApp.java
5.  *
6.  *  Execute: java TestCTimeApp
7.  */
9. import java.util.Calendar;
10. import java.util.GregorianCalendar;
12. public class TestCTimeApp {
13.    static String[] weekNames = {
14.                   "일", "월", "화", "수", "목", "금", "토"
15.               };
17.    public static void main(String[] args) {
18.         Calendar now = new GregorianCalendar();
20.         // 1970년 1월 1일 0시 0분 0초부터 시작하여 현재까지의 초
21.         System.out.println("UTC: " + (now.getTime().getTime() / 1000L) + "초");
23.         // 현재 시각 표시: 200x년 x월 xx일 (x요일) xx시 xx분 xx초
24.         System.out.print(now.get(Calendar.YEAR) + "년 ");
25.         System.out.print((1 + now.get(Calendar.MONTH)) + "월 ");
26.         System.out.print(now.get(Calendar.DAY_OF_MONTH) + "일 ");
27.         System.out.print("(" + weekNames[now.get(Calendar.DAY_OF_WEEK)] + "요일) ");
28.         System.out.print(now.get(Calendar.HOUR_OF_DAY) + "시 ");
29.         System.out.print(now.get(Calendar.MINUTE) + "분 ");
30.         System.out.println(now.get(Calendar.SECOND) + "초");
32.         // 1월 1일은 1, 1월 2일은 2
33.         System.out.print("올해 몇 번째 날: " + now.get(Calendar.DAY_OF_YEAR) + ", ");
35.         // 0 이면 서머타임 없음
36.         System.out.println("서머타임 적용 여부: " + (now.get(Calendar.DST_OFFSET) == 0 ? "안함" : "함"));
37.     }
38. }

컴파일> javac -d . TestCTimeApp.java

실행> java TestCTimeApp
UTC: 1206323913초
2008년 3월 24일 (화요일) 10시 58분 33초
올해 몇 번째 날: 84, 서머타임 적용 여부: 안함





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

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

1. /*
2.  *  Filename: testCTimeCPP.cpp
3.  *
4.  *  Compile: cl -GX testCTimeCPP.cpp
5.  *
6.  *  Execute: testCTimeCPP
7.  */
9. #include <iostream>
10. #include <ctime>
12. using namespace std;
14. char weekNames[7][3] = {
15.     "일", "월", "화", "수", "목", "금", "토"
16. };
18. int main() {
19.     time_t timer;
20.     struct tm *t;
22.     timer = time(NULL); // 현재 시각을 초 단위로 얻기
23.     t = localtime(&timer); // 초 단위의 시간을 분리하여 구조체에 넣기
25.     // 1970년 1월 1일 0시 0분 0초부터 시작하여 현재까지의 초
26.     cout << "UTC: " << timer << "초" << endl;
28.     // 현재 시각 표시: 200x년 x월 xx일 (x요일) xx시 xx분 xx초
29.     cout << (t->tm_year + 1900) << "년 " << (t->tm_mon + 1) << "월 " << t->tm_mday << "일 (" << weekNames[t->tm_wday] << "요일) ";
30.     cout << t->tm_hour << "시 " << t->tm_min << "분 " << t->tm_sec << "초" << endl;
33.     // t->tm_yday의 값: 1월 1일은 0, 1월 2일은 1
34.     cout << "올해 몇 번째 날: " << (1 + t->tm_yday);
36.     // t->tm_isdst의 값: 0 이면 서머타임 없음
37.     cout << "서머타임 적용 여부: " << ((t->tm_isdst == 0) ? "안함" : "함") << endl;
38.     return 0;
39. }

컴파일> cl testCTimeCPP.cpp

실행> testCTimeCPP
 UTC: 1206323262초
2008년 3월 24일 (월요일) 10시 47분 42초
올해 몇 번째 날: 84서머타임 적용 여부: 안함

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

1. /*
2.  *  Filename: testCTime.c
3.  *
4.  *  Compile: cl testCTime.c
5.  *
6.  *  Execute: testCTime
7.  */
9. #include <stdio.h>
10. #include <time.h>
12. char weekNames[7][3] = {
13.  "일", "월", "화", "수", "목", "금", "토"
14. };
16. int main() {
17.     time_t timer;
18.     struct tm *t;
20.     timer = time(NULL); // 현재 시각을 초 단위로 얻기
21.     t = localtime(&timer); // 초 단위의 시간을 분리하여 구조체에 넣기
23.     // 1970년 1월 1일 0시 0분 0초부터 시작하여 현재까지의 초
24.     printf("UTC: %d초\n", timer);
26.     // 현재 시각 표시: 200x년 x월 xx일 (x요일) xx시 xx분 xx초
27.     printf("%d년 %d월 %d일 (%s요일) ", t->tm_year + 1900, t->tm_mon + 1, t->tm_mday, weekNames[t->tm_wday]);
28.     printf("%d시 %d분 %d초\n", t->tm_hour, t->tm_min, t->tm_sec);
30.     // t->tm_yday의 값: 1월 1일은 0, 1월 2일은 1
31.     printf("올해 몇 번째 날: %d, ", 1 + t->tm_yday);
33.     // t->tm_isdst의 값: 0 이면 서머타임 없음
34.     printf("서머타임 적용 여부: %s\n", (t->tm_isdst == 0) ? "안함" : "함");
35.     return 0;
36. }

컴파일> cl testCTime.c

실행> testCTime
UTC: 1206322402초
2008년 3월 24일 (월요일) 10시 33분 22초
올해 몇 번째 날: 84, 서머타임 적용 여부: 안함

다음 소스 코드는 http://www.daniweb.com/code/snippet808.html 에서 볼 수 있는 (주어진 범위 안에서) 소수(prime number, 북한 용어로는 씨수) 찾기 C++ 소스 코드이다.
 

1. # include<iostream.h>
2. # include<math.h>
4. void main()
5. {
6.     int flag=0;
7.     unsigned long l, h, temp;
9.     cout<<"Enter the lower limit:"; cin>>l;
10.     cout<<"Enter the higher limit:"; cin>>h;
12.     if(l%2==0)
13.     {
14.          if(l==2) cout<<"2\t";
15.          l++; //taking only odd no
16.     }
18.      for(;l<=h;l+=2, flag=0)
19.      {
20.           temp=sqrt(l);
21.           if(temp%2==0) temp++; //taking only odd no
23.           for(; temp>2; temp--)
24.          {
25.              if(l%temp==0)
26.              {
27.                  flag=1;
28.                  break;
29.               }
30.          }
32.          if(flag==0) cout<<l<<"\t";
33.     }
34. }
    

1. #include <iostream.h>
2. # include <math.h>
4. void main() {
6.     int flag = 0;
7.     unsigned long l, h, temp;
9.     cout << "Enter the lower limit: ";
10.     cin >> l;
11.     cout << "Enter the upper limit: ";
12.     cin >> h;
14.     if (l % 2 == 0) {
15.          if (l == 2)
16.              cout << "2\t";
17.          l++;    //  Taking only odd numbers.
18.     }
20.     for (; l <= h; l += 2, flag = 0) {
21.         temp = sqrt(l);
22.         if (temp % 2 == 0)
23.            temp++;    //  Taking only odd numbers.
25.         for (; temp > 2; temp--) {
26.            if (l % temp == 0) {
27.                flag = 1;
28.                break;
29.            }
30.        }
32.        if (flag == 0)
33.            cout << l << "\t";
34.     }
35. }

하지만 아직 표준 C++에 맞지 않으므로 더 고쳐 보았다.

1. #include <iostream>
2. #include <cmath>
4. using namespace std;
6. void main() {
8.     int flag = 0;
9.     unsigned long l, h, temp;
11.     cout << "Enter the lower limit: ";
12.     cin >> l;
13.     cout << "Enter the upper limit: ";
14.     cin >> h;
16.     if (l % 2 == 0) {
17.          if (l == 2)
18.              cout << "2\t";
19.          l++;    //  Taking only odd numbers.
20.     }
22.     for (; l <= h; l += 2, flag = 0) {
23.         temp = sqrt(l);
24.         if (temp % 2 == 0)
25.            temp++;    //  Taking only odd numbers.
27.         for (; temp > 2; temp--) {
28.            if (l % temp == 0) {
29.                flag = 1;
30.                break;
31.            }
32.        }
34.        if (flag == 0)
35.            cout << l << "\t";
36.     }
37. }

            for (; temp > 2; temp--) {
               if (l % temp == 0) {
                   flag = 1;
                   break;
               }
          }

예를 들어 l =  3*1999993 = 5999979 인 경우 sqrt(5999979) ≒ 2449.5 이므로,
for 반복문을 시작하면서 temp = 2995 되고 t = 3 이 될 때 까지 무려 1496번을 반복하게 된다.
이 반복문 안의 나눗셈 과정  l % temp 부분을 l % 3 부터 시작하여 l % 5, l % 7, l % 9 ... 이런 식으로 증가시키면서 반복하는 과정으로 진행한다면, l =  3*1999993 = 5999979 인 경우 ㅣ% 3 = 0 이므로 더 이상 반복하지 않고 바로 반복문을 탈출하고 5999979는 소수가 아니라고 판정내린다.

이런 이유로 인하여, 위 소스 코드를 리팩토링하여 다음 처럼 수정하였다.

1. #include <iostream>
2. #include <cmath>
4. using namespace std;
6. void main() {
8.     int flag = 0;
9.     unsigned long l, h, j, temp;
11.     cout << "Enter the lower limit: ";
12.     cin >> l;
13.     cout << "Enter the upper limit: ";
14.     cin >> h;
16.     if (l % 2 == 0) {
17.          if (l == 2)
18.              cout << "2\t";
19.          l++;    //  Taking only odd numbers.
20.     }
22.     for (; l <= h; l += 2, flag = 0) {
23.         temp = sqrt(l);
24.         if (temp % 2 == 0)
25.            temp++;    //  Taking only odd numbers.
27.         for (j = 3L; j <= temp; j += 2L) {
28.            if (l % j == 0L) {
29.                flag = 1;
30.                break;
31.            }
32.        }
34.        if (flag == 0)
35.            cout << l << "\t";
36.     }
37. }

 
컴파일> cl /GX findPrimes.cpp

실행> findPrimes
Enter the lower limit: 200
Enter the upper limit: 500
211     223     227     229     233     239     241     251     257     263
269     271     277     281     283     293     307     311     313     317
331     337     347     349     353     359     367     373     379     383
389     397     401     409     419     421     431     433     439     443
449     457     461     463     467     479     487     491     499

GMP는 The GNU Multiple Precision Arithmetic Library(고정밀도 연산을 위한 GNU 라이브러리)의 줄임글로서 GNU MP라고도 한다. 리눅스 호환 환경이면 대부분 GMP는 이미 설치되어 있을 것이다. GMP의 공식 홈페이지는 http://gmplib.org 이고, GMP는 LGPL 하에서 배포된다.

또 gcc는 리눅스 호환 환경에서 쓸 수 있는 C 컴파일러(GNU C 컴파일러)이다. 대부분의 리눅스 호환 환경에는 gcc가  설치되어 있을 것이다.

다음 소스 코드는 GMP의 설치 테스트를 하기 위한 간단한 예제이다.

C 언어에서 GMP 라이브러리를 사용하기 위해서는 헤더 파일 gmp.h를 인클루드한다.
컴파일할 때는 반드시 컴파일 옵션 -lgmp 를 주어야 한다.
또 컴파일 옵션 -o testGMP 을 준 것은 생성될 실행파일명을 testGMP로 하라는 의미이다.
이 옵션을 생략하면 생성되는 실행파일명이 a.out(단, cygwin의 경우에는 a.exe)이다.

((  참고로, Visual C++ 6 에서 컴파일하는 명령은
           cl -I. testGMP.c /link gmp.lib /NODEFAULTLIB:LIBCMT
이다. 필자는 Visual C++ 6 에서 GMP 라이브러리를 사용하기 위해 영국에 사는 Brian Gladman 씨가 http://www.gladman.me.uk/computing/ 에서 제공하는 gmp-4.1.4.diffs.zip 을 써서 Visual C++ 6 용 GMP 라이브러리 gmp.lib 를 빌드하였다. ))

mpz_mul_ui 함수는 mpz_t 타입의 정수에 unsigned long 타입의 정수를 곱하는 함수이고,
mpz_add_ui 함수는 mpz_t 타입의 정수에 unsigned long 타입의 정수를 합하는 함수이다.

        mpz_init(r);

mpz_init 함수는 mpz_t 타입의 정수 변수를 초기화 하는 함수이다. (초기화된 값은 0)

       mpz_init_set_str(n, "123456", 10);

또 mpz_init_set_str 함수는 두번째 인수에 주어진 ASCIZ 문자열을 세 번째 인수에 주어진 적당한 진법(이 예에서는 10)을 적용하여 첫번째 인수에 주어진 mpz_t 타입의 정수 변수(이 예에서는 n)에 저장하는 함수이다.

1. /*
2.  *  Filename: testGMP.c
3.  *
4.  *   Compile: gcc -o testGMP testGMP.c -lgmp
5.  *
6.  *   Execute: ./testGMP
7.  *    Output: 2470450
8.  */
10. #include <gmp.h>
12. void foo(mpz_t result, const mpz_t param, unsigned long n) {
13.     unsigned long i;
14.     mpz_mul_ui(result, param, n);
15.     for (i = 1; i < n; i++) {
16.         mpz_add_ui (result, result, i*7);
17.     }
18. }
20. int main(void) {
21.     mpz_t r, n;
22.     mpz_init(r);
23.     mpz_init_set_str(n, "123456", 10);
24.     foo(r, n, 20L);
25.     gmp_printf("%Zd\n", r);
26.     return 0;
27. }

컴파일> gcc -o testGMP testGMP.c -lgmp

실행> ./testGMP
2470450



Win32의 Visual C++ 6 상에서 컴파일하기:
컴파일>cl -I. testGMP.c /link gmp.lib /NODEFAULTLIB:LIBCMT

실행> testGMP
2470450



Visual C++ 9.0 (Visual Studio 2008) 에서 컴파일하기:
컴파일>cl testGMP.c gmp.lib

실행> testGMP
2470450

GMP는 The GNU Multiple Precision Arithmetic Library(고정밀도 연산을 위한 GNU 라이브러리)의 줄임글로서 GNU MP라고도 한다. 리눅스 호환 환경이면 대부분 GMP는 이미 설치되어 있을 것이다. GMP의 공식 홈페이지는 http://gmplib.org 이고, GMP는 LGPL 하에서 배포된다.

또 g++는 리눅스 호환 환경에서 쓸 수 있는 C++ 컴파일러(GNU C++ 컴파일러)이다. 대부분의 리눅스 호환 환경에는 g++도 역시 설치되어 있을 것이다.

다음 소스 코드는 GMP의 설치 테스트를 하기 위한 간단한 예제이다.

C 언어에서 GMP 라이브러리를 사용하기 위해서는 헤더 파일 gmp.h를 인클루드 하지만,
C++ 언어에서 GMP 라이브러리를 사용하기 위해서는 헤더 파일 gmpxx.h를 인클루드 한다.

헤더 파일 iostream.h 를 인클루드하고, 이름 공간 std를 사용한 것은 cout 구문을 쓰기 위함이다.
컴파일할 때는 반드시 컴파일 옵션 -lgmpxx -lgmp 을 주어야 한다. (순서도 중요함)
또 컴파일 옵션 -o testGMPXX 을 준 것은 생성될 실행파일명을 testGMPXX로 하라는 의미이다.
이 옵션을 생략하면 생성되는 실행파일명이 a.out(단, cygwin의 경우에는 a.exe)이다.

아래의 소스 코드 중에서

      b = "-5678";

부분은 b가 이미 mpz_class 타입으로 선언되어 있기 때문에 스트링이 mpz_class 타입으로 자동변환하게 된다. 즉, C 언어에서

     mpz_t  b;
     mpz_init_set_str(b, "-5678", 10);

라고 코딩한 것에 해당한다.

1. /*
2.  *  Filename:  testGMPXX.cc
3.  *
4.  *   Compile:  g++ -o testGMPXX testGMPXX.cc -lgmpxx -lgmp
5.  *
6.  *   Execute:  ./testGMPXX
7.  */
9. #include <gmpxx.h>
10. #include <iostream>
12. using namespace std;
14. int main (void) {
15.     mpz_class a, b, c;
16.     a = 1234;
17.     b = "-5678";
18.     c = a + b;
19.     cout << "sum is " << c << "\n";
20.     cout << "absolute value is " << abs(c) << "\n";
21.      return 0;
22. }

컴파일> g++ -o testGMPXX testGMPXX.cc -lgmpxx -lgmp

실행> ./testGMPXX
sum is -4444
absolute value is 4444




* Visual C++ 9.0 (Visual Studio 2008) 에서 컴파일하기:
컴파일>cl testGMPXX.cpp gmp.lib

실행> testGMPXX
sum is -4444
absolute value is 4444



** 영문  위키피디아에서 소개하는 MinGW

** MinGW 의 공식 웹사이트에서 MinGW 를 설치하면 gcc 버전이 3.4.5 밖에 되지 않고,
    gmp 라이브러리도 수동으로 설치헤야 하는 번거로움이 있으므로,
    여기서는 Luna MinGW 를 설치하기로 한다. Luna MinGW 를 설치하면,
    현재 최신 버전인 gcc4.5.0 을 쓸 수 있다. 그 대신 g++ 로 컴파일 후에 쓰일 
    런타임 다이나믹 라이브러리 libgmpxx-4.dll 은 별도로 구하여 설치해야 한다.

** 윈도우에 Luna MinGW (with GCC 4.5.0) 설치하기:
      * Luna MinGW 홈페이지(MinGW GCC C/C++ Compiler package with installer) 
      * Luna MinGW 설치파일 다운로드
      1) 설치는 C:\MinGW 에 한것으로 간주한다.
      2) gcc 에서 gmp 라이브러리는 추가 설치 없이 바로 쓸 수 있는데,
         g++ 로는 컴파일은 되지만 컴파일된 실행파일을 실행하면 
         limgmpxx-4.dll 파일이 없다고 에러가 날 것이다. 이때는 아래 처럼 
         limgmpxx-4.dll 파일을 컴파일해서 만들던가 이미 만들어진 것을 PATH 가
         걸려 있는 곳에 넣어두어야 한다.
         아래는 limgmpxx-4.dll 파일을 구할 수 있는 곳이다. 
       
** g++에서 gmp를 사용하기 위해 libgmpxx-4.dll 구하여 설치하기:
      * 소스포지에서 libgmpxx-5.0.1-1-mingw32-dll-4.tar.lzma 다룬로드하기
      1)  확장명이 lzma 인 파일은 7zip 으로 풀어야 한다.
      2) 위의 파일을 받아서 7zip으로 압축 해제하여 libgmpxx-4.dll 을
          C:\MinGW\bin 에 복사힌다.
         (C:\MinGW 은 Luna MinGW 가 설치된 디렉토리이다)

** gcc 버전 확인하기
C:\test\mingw>gcc -v
Using built-in specs.
COLLECT_GCC=gcc
COLLECT_LTO_WRAPPER=c:/mingw/bin/../libexec/gcc/mingw32/4.5.0/lto-wrapper.exe
Target: mingw32
Configured with: ../gcc-4.5.0/configure --enable-languages=c,c++,ada,fortran,obj
c,obj-c++ --disable-sjlj-exceptions --with-dwarf2 --enable-shared --enable-libgo
mp --disable-win32-registry --enable-libstdcxx-debug --enable-version-specific-r
untime-libs --disable-werror --build=mingw32 --prefix=/mingw
Thread model: win32
gcc version 4.5.0 (GCC)

** g++ 버전 확인하기
C:\test\mingw>g++ -v
Using built-in specs.
COLLECT_GCC=g++
COLLECT_LTO_WRAPPER=c:/mingw/bin/../libexec/gcc/mingw32/4.5.0/lto-wrapper.exe
Target: mingw32
Configured with: ../gcc-4.5.0/configure --enable-languages=c,c++,ada,fortran,obj
c,obj-c++ --disable-sjlj-exceptions --with-dwarf2 --enable-shared --enable-libgo
mp --disable-win32-registry --enable-libstdcxx-debug --enable-version-specific-r
untime-libs --disable-werror --build=mingw32 --prefix=/mingw
Thread model: win32
gcc version 4.5.0 (GCC)


** Luna MinGW의 GCC 4.5.0 의 g++로 컴파일하기 (소스 파일의 확장명을 cc로 바꾸었다):
C:\test\mingw>g++ -o testGMPXX testGMPXX.cc -lgmpxx -lgmp

C:\test\mingw>testGMPXX
sum is -4444
absolute value is 4444





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

다항식 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)는 몫이다.

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

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

컴파일> cl -EHsc testSyntheticDivisionCPP.cpp

실행> testSyntheticDivisionCPP 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 로 나눌 때의 몫과 나머지를 구하는 조립제법을
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